Author: alex.guizar(a)jboss.com Date: 2009-05-04 05:33:28 -0400 (Mon, 04 May 2009) New Revision: 4706 Added: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassUtil.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/Semaphore.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ArchiveDeployer.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestHelper.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestSetup.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/JBossArchiveDeployer.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ObjectNameFactory.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/resources/jboss405-dependencies.txt Removed: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/CollectionUtil.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/StaticUtil.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/db/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.classpath Modified: jbpm3/branches/jbpm-3.2.5.SP/hudson/ant.properties.example jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/command.sh jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/config.xml jbpm3/branches/jbpm-3.2.5.SP/modules/core/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/core/pom.xml jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/AbstractJbpmTestCase.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/AntHelper.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/JbpmSchemaTask.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/ShutDownHsqldb.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractProcessInstanceBaseCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractTokenBaseCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/BatchSignalCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelTokenCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelWorkOnTaskCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ChangeProcessInstanceVersionCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CompositeCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/DeleteProcessDefinitionCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionsCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceLogCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstancesCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskListCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/NewProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeTokenCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SignalCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartWorkOnTaskCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendProcessInstanceCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendTokenCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/TaskInstanceEndCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/VariablesCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/impl/CommandServiceImpl.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/configuration/ObjectFactoryImpl.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/AbstractDbTestCase.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/GraphSession.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JbpmSchema.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JobSession.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/LoggingSession.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/TaskMgmtSession.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Action.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/EventCallback.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Node.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/Token.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Decision.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/EndState.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Fork.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Join.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/StartState.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/State.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/TaskNode.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/Timer.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/JobExecutorThread.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/LockMonitorThread.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/jpdl/xml/JpdlXmlWriter.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationService.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationServiceFactory.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/svc/Services.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassLoaderUtil.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/SerializabilityTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ChangeProcessInstanceVersionCommandTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/TokenVariableMapDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableInstanceDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableQueryDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/JbpmSchemaDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/TaskMgmtSessionDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessCancellationTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessPlusConcurrencyDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/node/JoinDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1072/JBPM1072Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1106/JBPM1106Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1135/JBPM1135Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1452/JBPM1452Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1755/JBPM1755Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1778/JBPM1778Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2036/JBPM2036Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/EsbActionHandler.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/JBPM2094Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm983/JBPM983Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/job/executor/JobExecutorDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/par/ProcessClassLoaderTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/xml/AbstractXmlTestCase.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/logging/exe/LoggingConfigDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/SimplePerformanceTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/TaskWithVariablesTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/seam/JobExecutorCustomizationTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/SwimlaneDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/TaskMgmtDefinitionDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskMgmtInstanceDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskTimerExecutionDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskVariablesDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/log/SwimlaneLogDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/resources/org/jbpm/context/exe/CustomSerializable.zip jbpm3/branches/jbpm-3.2.5.SP/modules/db/.project jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.project jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/pom.xml jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/ant-actions-spec.xml jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/auto-install-template.xml jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/download-helper.xml jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/install-definition.xml jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/user-input-spec.xml jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/pom.xml jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobsCommand.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/AppServerConfigurationsTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/ContainerProvidedJarsTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ejbtimer/EjbSchedulerTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jbpm1903/JBPM1903Test.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jms/JmsMessageTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jta/JtaDbPersistenceTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/examples/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/assignment/RulesAssignmentTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/businesstrip/BusinessTripRequestTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/raise/RaiseRequestTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/rulesaction/RulesActionTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/taskinstance/CustomTaskInstanceTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/identity/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/.classpath jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/jpdl/SimulationDefinition.java jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/report/ScenarioReport.java jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/BusinessFiguresTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/VariableSourceAndFilterTest.java jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.project jbpm3/branches/jbpm-3.2.5.SP/pom.xml jbpm3/branches/jbpm-3.2.5.SP/profiles.xml.example Log: [JBPM-2205] restore compatibility with jdk 1.4.2 Modified: jbpm3/branches/jbpm-3.2.5.SP/hudson/ant.properties.example =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/hudson/ant.properties.example 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/hudson/ant.properties.example 2009-05-04 09:33:28 UTC (rev 4706) @@ -11,6 +11,7 @@ jboss.bind.address=127.0.0.1 # JDK settings +java.home.jdk14=/usr/java/jdk1.4.2_17 java.home.jdk15=/usr/java/jdk1.5.0_15 java.home.jdk16=/usr/java/jdk1.6.0_06 @@ -28,9 +29,9 @@ hudson.admin.port=8150 hudson.http.port=8180 -#hudson.jboss422.zip=file:///home/hudson/download/java/jboss/jboss-4.2.2.GA.zip -#hudson.jboss423.zip=file:///home/hudson/download/java/jboss/jboss-4.2.3.GA.zip -#hudson.jboss500.zip=file:///home/hudson/download/java/jboss/jboss-5.0.0.GA.zip +#hudson.jboss405.zip=file:/home/hudson/download/java/jboss/jboss-4.0.5.GA.zip +#hudson.jboss423.zip=file:/home/hudson/download/java/jboss/jboss-4.2.3.GA.zip +#hudson.jboss501.zip=file:/home/hudson/download/java/jboss/jboss-5.0.1.GA.zip hudson.mail.recipients= hudson.smtp.host=localhost Modified: jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/command.sh =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/command.sh 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/command.sh 2009-05-04 09:33:28 UTC (rev 4706) @@ -10,16 +10,16 @@ DISTRODIR=$JBPMDIR/modules/distribution/target case "$CONTAINER" in - jboss422*) - JBOSS_BUILD=jboss-4.2.2.GA + jboss405*) + JBOSS_BUILD=jboss-4.0.5.GA ;; jboss423*) JBOSS_BUILD=jboss-4.2.3.GA ;; - jboss500*) - JBOSS_BUILD=jboss-5.0.0.GA + jboss501*) + JBOSS_BUILD=jboss-5.0.1.GA ;; esac Modified: jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/config.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/config.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/hudson/hudson-home/config.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -14,6 +14,10 @@ </systemMessage> <jdks> <jdk> + <name>jdk1.4</name> + <javaHome&gt;@java.home.jdk14(a)&lt;/javaHome&gt; + </jdk> + <jdk> <name>jdk1.5</name> <javaHome&gt;@java.home.jdk15(a)&lt;/javaHome&gt; </jdk> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,7 +4,7 @@ <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/> <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> <classpathentry kind="output" path="target/classes"/> </classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/pom.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/pom.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/pom.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -103,11 +103,6 @@ <artifactId>hsqldb</artifactId> <scope>test</scope> </dependency> - <dependency> - <groupId>mysql</groupId> - <artifactId>mysql-connector-java</artifactId> - <scope>test</scope> - </dependency> </dependencies> <!-- Plugins --> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/AbstractJbpmTestCase.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/AbstractJbpmTestCase.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/AbstractJbpmTestCase.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -27,42 +27,38 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -public abstract class AbstractJbpmTestCase extends TestCase -{ +public abstract class AbstractJbpmTestCase extends TestCase { + private static Log log = LogFactory.getLog(AbstractJbpmTestCase.class); - - protected void setUp() throws Exception - { - log.debug("### START " + getLongName() + " ####################################################"); + + protected void setUp() throws Exception { + log.debug("### START " + + getLongName() + + " ####################################################"); } - protected void tearDown() throws Exception - { - log.debug("### END " + getLongName() + " ######################################################"); + protected void tearDown() throws Exception { + log.debug("### END " + + getLongName() + + " ######################################################"); } - - protected String getShortName() - { + + protected String getShortName() { String shortName = getClass().getName(); return shortName.substring(shortName.lastIndexOf('.') + 1) + "." + getName(); } - - protected String getLongName() - { + + protected String getLongName() { return getClass().getName() + "." + getName(); } - + protected void runTest() throws Throwable { try { super.runTest(); - } catch (AssertionFailedError e) { - log.error(""); - log.error("ASSERTION FAILURE: "+e.getMessage()); - log.error(""); + } + catch (AssertionFailedError e) { + log.error("ASSERTION FAILURE: " + e.getMessage()); throw e; - } catch (Throwable t) { - t.printStackTrace(); - throw t; } } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/AntHelper.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/AntHelper.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/AntHelper.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,24 +21,21 @@ */ package org.jbpm.ant; -import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Properties; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; import org.hibernate.cfg.Configuration; + import org.jbpm.JbpmConfiguration; -import org.jbpm.JbpmException; +import org.jbpm.util.ClassLoaderUtil; /** - * common strategy for jbpm ant tasks to obtain a hibernate SessionFactory. + * common strategy for jbpm ant tasks to obtain configuration instances. */ -public class AntHelper -{ +public class AntHelper { final static Map configurations = new HashMap(); final static Map jbpmConfigurations = new HashMap(); @@ -47,54 +44,30 @@ // prevent instantiation } - public static Configuration getConfiguration(String hibernateCfgResource, String hibernatePropertiesResource) - { - Object key = getKey(hibernateCfgResource, hibernatePropertiesResource); - Configuration configuration = (Configuration)configurations.get(key); - if (configuration == null) - { - log.debug("creating hibernate configuration from cfg '" + hibernateCfgResource + "' and properties '" + hibernatePropertiesResource + "'"); + public static Configuration getConfiguration(String hibernateCfg, String hibernateProperties) { + Object key = getKey(hibernateCfg, hibernateProperties); + Configuration configuration = (Configuration) configurations.get(key); + if (configuration == null) { configuration = new Configuration(); - configuration.configure(hibernateCfgResource); - if (hibernatePropertiesResource != null) - { - try - { - InputStream propertiesInputStream = AntHelper.class.getResourceAsStream(hibernatePropertiesResource); - if (propertiesInputStream == null) - throw new IllegalArgumentException("Cannot read properties: " + hibernatePropertiesResource); - - Properties properties = new Properties(); - properties.load(propertiesInputStream); - configuration.setProperties(properties); - } - catch (Exception ex) - { - ex.printStackTrace(); - throw new JbpmException("couldn't set properties '" + hibernatePropertiesResource + "'", ex); - } + configuration.configure(hibernateCfg); + + if (hibernateProperties != null) { + Properties properties = ClassLoaderUtil.getProperties(hibernateProperties); + configuration.addProperties(properties); } configurations.put(key, configuration); } - else - { - log.debug("got hibernate configuration from cfg '" + hibernateCfgResource + "' and properties '" + hibernatePropertiesResource + "' from the cache"); - } return configuration; } - public static JbpmConfiguration getJbpmConfiguration(String jbpmCfg) - { - JbpmConfiguration jbpmConfiguration = (JbpmConfiguration)jbpmConfigurations.get(jbpmCfg); - if (jbpmConfiguration == null) - { - if (jbpmCfg == null) - { + public static JbpmConfiguration getJbpmConfiguration(String jbpmCfg) { + JbpmConfiguration jbpmConfiguration = (JbpmConfiguration) jbpmConfigurations.get(jbpmCfg); + if (jbpmConfiguration == null) { + if (jbpmCfg == null) { jbpmConfiguration = JbpmConfiguration.getInstance(); } - else - { + else { jbpmConfiguration = JbpmConfiguration.getInstance(jbpmCfg); } @@ -103,13 +76,10 @@ return jbpmConfiguration; } - static Object getKey(String cfg, String properties) - { + static Object getKey(String cfg, String properties) { List key = new ArrayList(); key.add(cfg); key.add(properties); return key; } - - private static final Log log = LogFactory.getLog(AntHelper.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/JbpmSchemaTask.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/JbpmSchemaTask.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/JbpmSchemaTask.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -23,58 +23,44 @@ import java.io.FileOutputStream; import java.io.IOException; -import java.io.InputStream; import java.io.PrintStream; +import java.util.Iterator; import java.util.List; -import java.util.Properties; import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Project; import org.apache.tools.ant.Task; import org.hibernate.cfg.Configuration; import org.hibernate.tool.hbm2ddl.SchemaExport; import org.hibernate.tool.hbm2ddl.SchemaUpdate; -import org.hibernate.util.ConfigHelper; -public class JbpmSchemaTask extends Task -{ - String config; +public class JbpmSchemaTask extends Task { + + String config = "hibernate.cfg.xml"; String properties; - String action; + String action = "create"; String output; String delimiter; - public void execute() throws BuildException - { - if (action == null) - action = "create"; - - if (config == null) - config = "hibernate.cfg.xml"; - - List<Exception> exceptions = null; - try - { - Configuration configuration = getConfiguration(); - if ("drop".equalsIgnoreCase(action)) - { + public void execute() throws BuildException { + List exceptions; + try { + Configuration configuration = AntHelper.getConfiguration(config, properties); + if ("drop".equalsIgnoreCase(action)) { SchemaExport schemaExport = getSchemaExport(configuration); schemaExport.execute(false, false, true, false); exceptions = schemaExport.getExceptions(); } - else if ("create".equalsIgnoreCase(action)) - { + else if ("create".equalsIgnoreCase(action)) { SchemaExport schemaExport = getSchemaExport(configuration); schemaExport.execute(false, false, false, true); exceptions = schemaExport.getExceptions(); } - else if ("update".equalsIgnoreCase(action)) - { + else if ("update".equalsIgnoreCase(action)) { PrintStream fileOut = null; PrintStream systemOut = System.out; - try - { - if (output != null) - { + try { + if (output != null) { fileOut = new PrintStream(new FileOutputStream(output)); System.setOut(fileOut); } @@ -82,98 +68,58 @@ schemaUpdate.execute(true, false); exceptions = schemaUpdate.getExceptions(); } - finally - { - if (fileOut != null) - { + finally { + if (fileOut != null) { System.setOut(systemOut); fileOut.close(); } } } - else - { + else { throw new IllegalArgumentException("Unsupported action: " + action); } } - catch (IOException ex) - { + catch (IOException ex) { throw new BuildException(ex); } // Print the exceptions if there are any - for (Exception ex : exceptions) - log(ex.toString()); - } - - private Configuration getConfiguration() throws IOException - { - log("Action '" + action + "' using " + config + "," + properties); - Configuration configuration = new Configuration(); - configuration.configure(config); - - if (properties != null) - { - InputStream inStream = ConfigHelper.getResourceAsStream(properties); - if (inStream == null) - throw new IllegalArgumentException("Cannot read properties: " + properties); - - try - { - Properties properties = new Properties(); - properties.load(inStream); - configuration.setProperties(properties); - } - finally - { - inStream.close(); - } + for (Iterator i = exceptions.iterator(); i.hasNext();) { + Object ex = i.next(); + log(ex.toString(), Project.MSG_ERR); } - return configuration; } - private SchemaExport getSchemaExport(Configuration configuration) - { + private SchemaExport getSchemaExport(Configuration configuration) { SchemaExport schemaExport = new SchemaExport(configuration); - - if (output != null) - schemaExport.setOutputFile(output); - - if (delimiter != null) - schemaExport.setDelimiter(delimiter); - schemaExport.setFormat(false); + if (output != null) schemaExport.setOutputFile(output); + if (delimiter != null) schemaExport.setDelimiter(delimiter); return schemaExport; } - private SchemaUpdate getSchemaUpdate(Configuration configuration) - { + private SchemaUpdate getSchemaUpdate(Configuration configuration) { SchemaUpdate schemaUpdate = new SchemaUpdate(configuration); return schemaUpdate; } - public void setAction(String action) - { + public void setAction(String action) { this.action = action; } - public void setConfig(String config) - { + public void setConfig(String config) { this.config = config; } - public void setProperties(String properties) - { + public void setProperties(String properties) { this.properties = properties; } - public void setDelimiter(String delimiter) - { + public void setDelimiter(String delimiter) { this.delimiter = delimiter; } - public void setOutput(String output) - { + public void setOutput(String output) { this.output = output; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/ShutDownHsqldb.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/ShutDownHsqldb.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/ant/ShutDownHsqldb.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -6,34 +6,42 @@ import org.apache.tools.ant.BuildException; import org.apache.tools.ant.Task; +import org.hibernate.cfg.Configuration; import org.hibernate.connection.ConnectionProvider; -import org.hibernate.impl.SessionFactoryImpl; -import org.jbpm.JbpmConfiguration; -import org.jbpm.JbpmContext; -import org.jbpm.persistence.db.DbPersistenceServiceFactory; -import org.jbpm.svc.Services; +import org.hibernate.engine.SessionFactoryImplementor; public class ShutDownHsqldb extends Task { + private String config = "hibernate.cfg.xml"; + private String properties; + public void execute() throws BuildException { - Connection connection = null; - JbpmConfiguration jbpmConfiguration = AntHelper.getJbpmConfiguration(null); - JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); + Configuration configuration = AntHelper.getConfiguration(config, properties); + SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) configuration.buildSessionFactory(); + ConnectionProvider connectionProvider = sessionFactory.getConnectionProvider(); try { - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmContext.getServiceFactory(Services.SERVICENAME_PERSISTENCE); - SessionFactoryImpl sessionFactory = (SessionFactoryImpl) dbPersistenceServiceFactory.getSessionFactory(); - ConnectionProvider connectionProvider = sessionFactory.getConnectionProvider(); - connection = connectionProvider.getConnection(); + Connection connection = connectionProvider.getConnection(); Statement statement = connection.createStatement(); + log("shutting down database"); statement.executeUpdate("SHUTDOWN"); - connection.close(); - - } catch (SQLException e) { - e.printStackTrace(); - } finally { - jbpmContext.close(); + + connectionProvider.closeConnection(connection); } + catch (SQLException e) { + throw new BuildException("could not shut down database", e); + } + finally { + connectionProvider.close(); + } } + public void setConfig(String config) { + this.config = config; + } + + public void setProperties(String properties) { + this.properties = properties; + } + } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractProcessInstanceBaseCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractProcessInstanceBaseCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractProcessInstanceBaseCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,32 +1,29 @@ package org.jbpm.command; import java.util.ArrayList; -import java.util.Arrays; import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.util.ArrayUtil; /** - * Abstract base class for all commands working on {@link org.jbpm.graph.exe.ProcessInstance}s. + * Abstract base class for all commands working on {@link org.jbpm.graph.exe.ProcessInstance}s. The + * {@link ProcessInstance} can either be specified by id or multiple ids. The alternative is to + * specify a {@link ProcessDefinition} name and version. In this case <b>all</b> found + * {@link ProcessInstance}s are processed. If no version is specified, <b>all</b> versions are taken + * into account. if onlyRunning is set to false (default is true) already ended + * {@link ProcessInstance}s are processed too. * - * The {@link ProcessInstance} can either be specified by id or multiple ids. - * - * The alternative is to specify a {@link ProcessDefinition} name and version. - * In this case <b>all</b> found {@link ProcessInstance}s are processed. - * If no version is specified, <b>all</b> versions are taken into account. - * - * if onlyRunning is set to false (default is true) already ended {@link ProcessInstance}s - * are processed too. - * * @author bernd.ruecker(a)camunda.com */ -public abstract class AbstractProcessInstanceBaseCommand extends AbstractBaseCommand -{ +public abstract class AbstractProcessInstanceBaseCommand extends AbstractBaseCommand { + protected Log log = LogFactory.getLog(this.getClass()); private long[] processInstanceIds = null; @@ -35,47 +32,38 @@ private boolean onlyRunning = true; private boolean operateOnSingleObject; - + private transient JbpmContext jbpmContext; - public AbstractProcessInstanceBaseCommand() - { - super(); - } - + private static final long serialVersionUID = 1L; + protected JbpmContext getJbpmContext() { return jbpmContext; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { ArrayList result = new ArrayList(); this.jbpmContext = jbpmContext; - try { + try { log.debug("executing " + this); - + // batch tokens - if (processInstanceIds != null && processInstanceIds.length > 0) - { - for (int i = 0; i < processInstanceIds.length; i++) - { + if (processInstanceIds != null && processInstanceIds.length > 0) { + for (int i = 0; i < processInstanceIds.length; i++) { ProcessInstance pi = jbpmContext.loadProcessInstanceForUpdate(processInstanceIds[i]); - result.add( - execute(pi)); + result.add(execute(pi)); } } - + // search for ProcessInstances according to parameters - if (processName != null) - { + if (processName != null) { operateOnSingleObject = false; - + GetProcessInstancesCommand cmd = new GetProcessInstancesCommand(); - cmd.setProcessName(processName); + cmd.setProcessDefinitionName(processName); cmd.setOnlyRunning(onlyRunning); - if (processVersion>0) - cmd.setVersion(String.valueOf(processVersion)); - + if (processVersion > 0) cmd.setVersion(String.valueOf(processVersion)); + // Query query = null; // if (processVersion>0) { // query = jbpmContext.getSession().getNamedQuery("GraphSession.findProcessDefinitionByNameAndVersion"); @@ -85,24 +73,23 @@ // query = jbpmContext.getSession().getNamedQuery("GraphSession.findTokensForProcessInNode"); // } // query.setString("name", processName); - List processInstanceList = (List)cmd.execute(jbpmContext); - + List processInstanceList = (List) cmd.execute(jbpmContext); + Iterator iter = processInstanceList.iterator(); - while (iter.hasNext()) - { - ProcessInstance pi = (ProcessInstance)iter.next(); + while (iter.hasNext()) { + ProcessInstance pi = (ProcessInstance) iter.next(); execute(pi); } } - + if (operateOnSingleObject) { - if (result.size()<1) + if (result.size() < 1) return null; - else + else return result.get(0); } else { - return result; + return result; } } finally { @@ -111,116 +98,107 @@ } public abstract ProcessInstance execute(ProcessInstance processInstance); - - public void setProcessInstanceIds(long[] processInstanceIds) - { + + public void setProcessInstanceIds(long[] processInstanceIds) { this.operateOnSingleObject = false; this.processInstanceIds = processInstanceIds; } - public void setProcessInstanceId(long processInstanceId) - { + public void setProcessInstanceId(long processInstanceId) { this.operateOnSingleObject = true; this.processInstanceIds = new long[1]; - this.processInstanceIds[0] = processInstanceId; + this.processInstanceIds[0] = processInstanceId; } - + /** * Overwrite toString to keep semantic of getAdditionalToStringInformation */ public String toString() { - if (processName!=null) { - return this.getClass().getName() - + " [tokenIds=" + Arrays.toString(processInstanceIds) - + ";processName=" + processName - + ";processVersion=" + (processVersion>0 ? processVersion : "NA") - + getAdditionalToStringInformation() - + "]"; + if (processName != null) { + return this.getClass().getName() + + " [tokenIds=" + + ArrayUtil.toString(processInstanceIds) + + ";processName=" + + processName + + ";processVersion=" + + (processVersion > 0 ? Integer.toString(processVersion) : "NA") + + getAdditionalToStringInformation() + + "]"; } else { - return this.getClass().getName() - + " [tokenIds=" + Arrays.toString(processInstanceIds) - + ";operateOnSingleObject=" + operateOnSingleObject - + getAdditionalToStringInformation() - + "]"; + return this.getClass().getName() + + " [tokenIds=" + + ArrayUtil.toString(processInstanceIds) + + ";operateOnSingleObject=" + + operateOnSingleObject + + getAdditionalToStringInformation() + + "]"; } - } + } - public String getProcessName() - { + public String getProcessName() { return processName; } - public void setProcessName(String processName) - { + public void setProcessName(String processName) { this.processName = processName; } - - public int getProcessVersion() - { + + public int getProcessVersion() { return processVersion; } - public void setProcessVersion(int processVersion) - { + public void setProcessVersion(int processVersion) { this.processVersion = processVersion; } - public long[] getProcessInstanceIds() - { + public long[] getProcessInstanceIds() { return processInstanceIds; } /** - * return the process instance id in case only one - * process instance id is set. Otherwise an {@link IllegalStateException} - * is thrown + * return the process instance id in case only one process instance id is set. Otherwise an + * {@link IllegalStateException} is thrown */ - public long getProcessInstanceId() - { - if (processInstanceIds==null || processInstanceIds.length!=1) - throw new IllegalStateException("getProcessInstanceId can only be called if only one process instance id is set on command " + this + " but was " + processInstanceIds); + public long getProcessInstanceId() { + if (processInstanceIds == null || processInstanceIds.length > 1) { + throw new IllegalStateException("multiple process instance ids set: " + + ArrayUtil.toString(processInstanceIds)); + } return processInstanceIds[0]; } - public boolean isOnlyRunning() - { + public boolean isOnlyRunning() { return onlyRunning; } - public void setOnlyRunning(boolean onlyRunning) - { + public void setOnlyRunning(boolean onlyRunning) { this.onlyRunning = onlyRunning; } // methods for fluent programming - public AbstractProcessInstanceBaseCommand processInstanceIds(long[] processInstanceIds) - { - setProcessInstanceIds( processInstanceIds ); + public AbstractProcessInstanceBaseCommand processInstanceIds(long[] processInstanceIds) { + setProcessInstanceIds(processInstanceIds); return this; } - public AbstractProcessInstanceBaseCommand processInstanceId(long processInstanceId) - { - setProcessInstanceId(processInstanceId); + public AbstractProcessInstanceBaseCommand processInstanceId(long processInstanceId) { + setProcessInstanceId(processInstanceId); return this; } - public AbstractProcessInstanceBaseCommand processName(String processName) - { - setProcessName( processName ); + public AbstractProcessInstanceBaseCommand processName(String processName) { + setProcessName(processName); return this; } - - public AbstractProcessInstanceBaseCommand processVersion(int processVersion) - { - setProcessVersion( processVersion ); + + public AbstractProcessInstanceBaseCommand processVersion(int processVersion) { + setProcessVersion(processVersion); return this; } - public AbstractProcessInstanceBaseCommand onlyRunning(boolean onlyRunning) - { + public AbstractProcessInstanceBaseCommand onlyRunning(boolean onlyRunning) { setOnlyRunning(onlyRunning); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractTokenBaseCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractTokenBaseCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/AbstractTokenBaseCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,101 +1,89 @@ package org.jbpm.command; import java.util.ArrayList; -import java.util.Arrays; import java.util.Iterator; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hibernate.Query; + import org.jbpm.JbpmContext; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.Token; +import org.jbpm.util.ArrayUtil; /** - * Abstract base class for commands working on Tokens. + * Abstract base class for commands working on Tokens. The {@link Token} can either be specified by + * id or multiple ids. The alternative is to specify a {@link ProcessDefinition} name, a required + * node name and version. In this case <b>all</b> found {@link Token}s are processed. If no version + * is specified, <b>all</b> versions are taken into account. * - * The {@link Token} can either be specified by id or multiple ids. - * - * The alternative is to specify a {@link ProcessDefinition} name, a - * required node name and version. - * In this case <b>all</b> found {@link Token}s are processed. - * If no version is specified, <b>all</b> versions are taken into account. - * * @author bernd.ruecker(a)camunda.com */ -public abstract class AbstractTokenBaseCommand implements Command -{ +public abstract class AbstractTokenBaseCommand implements Command { + protected Log log = LogFactory.getLog(this.getClass()); private long[] tokenIds = null; private String processName = null; private String stateName = null; private int processVersion = 0; - + private boolean operateOnSingleObject; private transient JbpmContext jbpmContext; - public AbstractTokenBaseCommand() - { - super(); - } - + private static final long serialVersionUID = 1L; + protected JbpmContext getJbpmContext() { return jbpmContext; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { this.jbpmContext = jbpmContext; - try { + try { ArrayList result = new ArrayList(); log.debug("executing " + this); - + // batch tokens - if (tokenIds != null && tokenIds.length > 0) - { - for (int i = 0; i < tokenIds.length; i++) - { + if (tokenIds != null && tokenIds.length > 0) { + for (int i = 0; i < tokenIds.length; i++) { Token token = jbpmContext.loadTokenForUpdate(tokenIds[i]); - result.add( - execute(token)); + result.add(execute(token)); } } - + // search for tokens in process/state - if (processName != null && stateName != null) - { + if (processName != null && stateName != null) { this.operateOnSingleObject = false; - + Query query = null; - if (processVersion>0) { - query = jbpmContext.getSession().getNamedQuery("GraphSession.findTokensForProcessVersionInNode"); + if (processVersion > 0) { + query = jbpmContext.getSession().getNamedQuery( + "GraphSession.findTokensForProcessVersionInNode"); query.setInteger("processDefinitionVersion", processVersion); } else { - query = jbpmContext.getSession().getNamedQuery("GraphSession.findTokensForProcessInNode"); + query = jbpmContext.getSession().getNamedQuery("GraphSession.findTokensForProcessInNode"); } query.setString("processDefinitionName", processName); query.setString("nodeName", stateName); - + Iterator iter = query.list().iterator(); - while (iter.hasNext()) - { - Token token = (Token)iter.next(); - result.add( - execute(token)); + while (iter.hasNext()) { + Token token = (Token) iter.next(); + result.add(execute(token)); } } - + if (operateOnSingleObject) { - if (result.size()<1) + if (result.size() < 1) return null; - else + else return result.get(0); } else { - return result; + return result; } } finally { @@ -105,118 +93,109 @@ public abstract Object execute(Token token); - public void setTokenIds(long[] tokenIds) - { + public void setTokenIds(long[] tokenIds) { this.operateOnSingleObject = false; this.tokenIds = tokenIds; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.operateOnSingleObject = true; this.tokenIds = new long[1]; this.tokenIds[0] = tokenId; } - + public String getAdditionalToStringInformation() { return ""; } - public String getProcessName() - { + public String getProcessName() { return processName; } - public void setProcessName(String processName) - { + public void setProcessName(String processName) { this.processName = processName; } - public int getProcessVersion() - { + public int getProcessVersion() { return processVersion; } - public void setProcessVersion(int processVersion) - { + public void setProcessVersion(int processVersion) { this.processVersion = processVersion; } - public String getStateName() - { + public String getStateName() { return stateName; } - public void setStateName(String stateName) - { + public void setStateName(String stateName) { this.stateName = stateName; } - public long[] getTokenIds() - { + public long[] getTokenIds() { return tokenIds; } - + /** - * return the process instance id in case only one - * process instance id is set. Otherwise an {@link IllegalStateException} - * is thrown + * return the token id in case only one token id is set. Otherwise an + * {@link IllegalStateException} is thrown */ - public long getTokenId() - { - if (tokenIds==null || tokenIds.length!=1) - throw new IllegalStateException("getTokenIds can only be called if only one token id is set on command " + this + " but was " + tokenIds); + public long getTokenId() { + if (tokenIds == null || tokenIds.length != 1) { + throw new IllegalStateException("multiple token ids set: " + ArrayUtil.toString(tokenIds)); + } return tokenIds[0]; - } - + } + public String toString() { - if (processName!=null && stateName!=null) { - return this.getClass().getName() - + " [tokenIds=" + Arrays.toString(tokenIds) - + ";processName=" + processName - + ";processVersion=" + (processVersion>0 ? processVersion : "NA") - + ";stateName=" + stateName - + getAdditionalToStringInformation() - + "]"; + if (processName != null && stateName != null) { + return this.getClass().getName() + + " [tokenIds=" + + ArrayUtil.toString(tokenIds) + + ";processName=" + + processName + + ";processVersion=" + + (processVersion > 0 ? Integer.toString(processVersion) : "NA") + + ";stateName=" + + stateName + + getAdditionalToStringInformation() + + "]"; } else { - return this.getClass().getName() - + " [tokenIds=" + Arrays.toString(tokenIds) - + ";operateOnSingleObject=" + operateOnSingleObject - + getAdditionalToStringInformation() - + "]"; + return this.getClass().getName() + + " [tokenIds=" + + ArrayUtil.toString(tokenIds) + + ";operateOnSingleObject=" + + operateOnSingleObject + + getAdditionalToStringInformation() + + "]"; } } - + // methods for fluent programming - public AbstractTokenBaseCommand tokenIds(long[] tokenIds) - { + public AbstractTokenBaseCommand tokenIds(long[] tokenIds) { setTokenIds(tokenIds); return this; } - public AbstractTokenBaseCommand tokenId(long tokenId) - { + public AbstractTokenBaseCommand tokenId(long tokenId) { setTokenId(tokenId); return this; } - - public AbstractTokenBaseCommand processName(String processName) - { + + public AbstractTokenBaseCommand processName(String processName) { setProcessName(processName); return this; } - public AbstractTokenBaseCommand processVersion(int processVersion) - { + public AbstractTokenBaseCommand processVersion(int processVersion) { setProcessVersion(processVersion); return this; } - public AbstractTokenBaseCommand stateName(String stateName) - { + public AbstractTokenBaseCommand stateName(String stateName) { setStateName(stateName); return this; - } + } } \ No newline at end of file Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/BatchSignalCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/BatchSignalCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/BatchSignalCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,66 +5,59 @@ import org.jbpm.graph.exe.Token; /** - * a bunch of processes is signaled with this command. you can specify the - * tokens either - * <li>by a array of token ids - * <li>or by processName, processVersion (optional, without all versions), - * stateName + * a bunch of processes is signaled with this command. you can specify the tokens either <li>by a + * array of token ids <li>or by processName, processVersion (optional, without all versions), + * stateName transitionName specifies the transition to take (if null, the default transition is + * taken). * - * transitionName specifies the transition to take (if null, the default - * transition is taken). - * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ public class BatchSignalCommand extends AbstractTokenBaseCommand { - private static final long serialVersionUID = -4330623193546102772L; + private static final long serialVersionUID = -4330623193546102772L; - /** - * if set, only tokens which are started after this date are signaled - * (interesting to implement some timeout for example) - */ - private Date inStateAtLeastSince = null; + /** + * if set, only tokens which are started after this date are signaled (interesting to implement + * some timeout for example) + */ + private Date inStateAtLeastSince = null; - private String transitionName = null; + private String transitionName = null; - public Object execute(Token token) { - if (inStateAtLeastSince == null - || token.getNodeEnter().before(inStateAtLeastSince)) { + public Object execute(Token token) { + if (inStateAtLeastSince == null || token.getNodeEnter().before(inStateAtLeastSince)) { - log.debug("signal token " + token); - if (transitionName == null) { - token.signal(); - } else { - token.signal(transitionName); - } - } - return token; - } + log.debug("signal token " + token); + if (transitionName == null) { + token.signal(); + } + else { + token.signal(transitionName); + } + } + return token; + } - public String getTransitionName() { - return transitionName; - } + public String getTransitionName() { + return transitionName; + } - public void setTransitionName(String transitionName) { - this.transitionName = transitionName; - } + public void setTransitionName(String transitionName) { + this.transitionName = transitionName; + } - public Date getInStateAtLeastSince() { - return inStateAtLeastSince; - } + public Date getInStateAtLeastSince() { + return inStateAtLeastSince; + } - public void setInStateAtLeastSince(Date inStateAtLeastSince) { - this.inStateAtLeastSince = inStateAtLeastSince; - } + public void setInStateAtLeastSince(Date inStateAtLeastSince) { + this.inStateAtLeastSince = inStateAtLeastSince; + } - @Override - public String getAdditionalToStringInformation() - { - return ";transitionName=" + transitionName - + ";inStateAtLeastSince=" + inStateAtLeastSince; + public String getAdditionalToStringInformation() { + return ";transitionName=" + transitionName + ";inStateAtLeastSince=" + inStateAtLeastSince; } - + // methods for fluent programming public BatchSignalCommand transitionName(String transitionName) { Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,55 +1,47 @@ package org.jbpm.command; -import java.util.Date; - import org.jbpm.JbpmContext; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.exe.Token; import org.jbpm.util.Clock; /** - * Cancel the given {@link ProcessInstance} with all {@link Token}s. + * Cancel the given {@link ProcessInstance} with all {@link Token}s. <b>Maybe running sub process + * instances are currently not canceled.</b> * - * <b>Maybe running sub process instances are currently not canceled.</b> - * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class CancelProcessInstanceCommand extends AbstractCancelCommand -{ +public class CancelProcessInstanceCommand extends AbstractCancelCommand { private static final long serialVersionUID = 7145293049356621597L; - + private long processInstanceId; - public CancelProcessInstanceCommand() - { + public CancelProcessInstanceCommand() { } - public CancelProcessInstanceCommand(long processInstanceId) - { + public CancelProcessInstanceCommand(long processInstanceId) { this.processInstanceId = processInstanceId; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { this.jbpmContext = jbpmContext; cancelProcess(processInstanceId); this.jbpmContext = null; return null; } - protected void cancelProcess(long processIdToCancel) - { + protected void cancelProcess(long processIdToCancel) { ProcessInstance pi = jbpmContext.getGraphSession().loadProcessInstance(processIdToCancel); log.info("cancel process instance " + pi.getId()); // Record a standardized variable that we can use to determine that this // process has been 'canceled' and not just ended. - pi.getContextInstance().createVariable(CANCELLATION_INDICATOR_VARIABLE_NAME, Clock.getCurrentTime()); + pi.getContextInstance().createVariable(CANCELLATION_INDICATOR_VARIABLE_NAME, + Clock.getCurrentTime()); - try - { + try { // End the process instance and any open tokens // TODO: Think about maybe canceling sub processes? cancelToken(pi.getRootToken()); @@ -58,49 +50,41 @@ log.info("finished process cancellation"); } - catch (RuntimeException ex) - { + catch (RuntimeException ex) { log.error("problems while cancel process", ex); throw ex; } } - public long getProcessInstanceId() - { + public long getProcessInstanceId() { return processInstanceId; } - public void setProcessInstanceId(long processInstanceId) - { + public void setProcessInstanceId(long processInstanceId) { this.processInstanceId = processInstanceId; } /** * @deprecated use getProcessInstanceId instead */ - public long getProcessId() - { + public long getProcessId() { return processInstanceId; } /** * @deprecated use setProcessInstanceId instead */ - public void setProcessId(long processId) - { + public void setProcessId(long processId) { this.processInstanceId = processId; } - @Override - public String getAdditionalToStringInformation() - { + public String getAdditionalToStringInformation() { return "processInstanceId=" + processInstanceId; } - + // methods for fluent programming - public CancelProcessInstanceCommand processInstanceId(long processInstanceId) - { + public CancelProcessInstanceCommand processInstanceId(long processInstanceId) { setProcessInstanceId(processInstanceId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelTokenCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelTokenCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelTokenCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -9,24 +9,20 @@ * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class CancelTokenCommand extends AbstractCancelCommand -{ +public class CancelTokenCommand extends AbstractCancelCommand { private static final long serialVersionUID = 7145293049356621597L; private long tokenId; - public CancelTokenCommand() - { + public CancelTokenCommand() { } - public CancelTokenCommand(long tokenId) - { + public CancelTokenCommand(long tokenId) { this.tokenId = tokenId; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { this.jbpmContext = jbpmContext; Token token = jbpmContext.getGraphSession().loadToken(tokenId); @@ -34,31 +30,26 @@ token.getProcessInstance().getContextInstance().createVariable( CANCELLATION_INDICATOR_VARIABLE_NAME, Clock.getCurrentTime(), token); - cancelToken(token); + cancelToken(token); this.jbpmContext = null; return null; } - public long getTokenId() - { + public long getTokenId() { return tokenId; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.tokenId = tokenId; } - - @Override - public String getAdditionalToStringInformation() - { + + public String getAdditionalToStringInformation() { return "tokenId=" + tokenId; } // methods for fluent programming - public CancelTokenCommand tokenId(long tokenId) - { + public CancelTokenCommand tokenId(long tokenId) { setTokenId(tokenId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelWorkOnTaskCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelWorkOnTaskCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CancelWorkOnTaskCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,57 +4,47 @@ import org.jbpm.taskmgmt.exe.TaskInstance; /** - * The current authorizes actor starts to work on the TaskInstance so the actor is set to the given actor - * - * see some more information why we need that in the <a + * The current authorizes actor starts to work on the TaskInstance so the actor is set to the given + * actor see some more information why we need that in the <a * href="http://www.jboss.com/index.html?module=bb&op=viewtopic&... forum</a> * * @author Bernd Ruecker */ -public class CancelWorkOnTaskCommand extends AbstractBaseCommand -{ +public class CancelWorkOnTaskCommand extends AbstractBaseCommand { private static final long serialVersionUID = -172457633891242288L; private long taskInstanceId; - public CancelWorkOnTaskCommand(long taskInstanceId) - { + public CancelWorkOnTaskCommand(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public CancelWorkOnTaskCommand() - { + public CancelWorkOnTaskCommand() { } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { TaskInstance ti = jbpmContext.getTaskInstance(taskInstanceId); ti.setActorId(null); ti.setStart(null); return null; } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - @Override - public String getAdditionalToStringInformation() - { + public String getAdditionalToStringInformation() { return ";taskInstanceId=" + taskInstanceId; } - + // methods for fluent programming - public CancelWorkOnTaskCommand taskInstanceId(long taskInstanceId) - { + public CancelWorkOnTaskCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ChangeProcessInstanceVersionCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ChangeProcessInstanceVersionCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ChangeProcessInstanceVersionCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hibernate.Query; + import org.jbpm.JbpmException; import org.jbpm.graph.def.GraphElement; import org.jbpm.graph.def.Node; @@ -24,38 +25,29 @@ /** * <b>THIS COMMAND IS NOT YET STABLE, BUT FEEL FREE TO TEST :-)</b><br> - * - * Status update: Still not complete, but refactored and added simple test cases: + * Status update: Still not complete, but refactored and added simple test cases: * {@link ChangeProcessInstanceVersionCommandTest}.<br> - * - * Change the version of a running process instance. - * - * This works only, if the current node is also available in the new - * version of the process definition or a name mapping has to be provided.<br> - * + * Change the version of a running process instance. This works only, if the current node is also + * available in the new version of the process definition or a name mapping has to be provided.<br> * <b>Currently known limitations:</b> * <ul> - * <li> {@link Task}s cannot move "into" another node. If an active - * {@link TaskInstance} exists, the {@link Task} definition must - * exist in the {@link TaskNode} with the same (or mapped) name. - * Otherwise the right node cannot be found easily because it may be - * ambiguous.</li> - * <li> Sub processes aren't yet tested. Since the {@link ProcessState} is - * a {@link Node} like any other, it should work anyway.</li> - * <li> Can have <b>negative impact on referential integrity</b>! Because - * one {@link ProcessInstance} can have {@link ProcessLog}s point to - * old {@link ProcessDefinition}s. Hence, delete a {@link ProcessDefinition} - * may not work and throw an Exception (Integrity constraint violation)</li> - * <li> In combination with ESB the ESB uses {@link Token}.id <b>and</b> {@link Node}.id - * as correlation identifier. After changing the version of a {@link ProcessInstance} - * the {@link Node}.id has changed, so a signal from ESB will result in an exception - * and has to be corrected manually.</li> + * <li> {@link Task}s cannot move "into" another node. If an active {@link TaskInstance} exists, the + * {@link Task} definition must exist in the {@link TaskNode} with the same (or mapped) name. + * Otherwise the right node cannot be found easily because it may be ambiguous.</li> + * <li>Sub processes aren't yet tested. Since the {@link ProcessState} is a {@link Node} like any + * other, it should work anyway.</li> + * <li>Can have <b>negative impact on referential integrity</b>! Because one {@link ProcessInstance} + * can have {@link ProcessLog}s point to old {@link ProcessDefinition}s. Hence, delete a + * {@link ProcessDefinition} may not work and throw an Exception (Integrity constraint violation)</li> + * <li>In combination with ESB the ESB uses {@link Token}.id <b>and</b> {@link Node}.id as + * correlation identifier. After changing the version of a {@link ProcessInstance} the {@link Node} + * .id has changed, so a signal from ESB will result in an exception and has to be corrected + * manually.</li> * </ul> * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class ChangeProcessInstanceVersionCommand extends AbstractProcessInstanceBaseCommand -{ +public class ChangeProcessInstanceVersionCommand extends AbstractProcessInstanceBaseCommand { private static final long serialVersionUID = 2277080393930008224L; @@ -67,64 +59,68 @@ private static final Log log = LogFactory.getLog(ChangeProcessInstanceVersionCommand.class); /** - * the map configures for every node-name in the old process definition - * (as key) which node-name to use in the new - * process definition. - * - * if a node is not mentioned in this Map, - * old node name = new node name is applied + * the map configures for every node-name in the old process definition (as key) which node-name + * to use in the new process definition. if a node is not mentioned in this Map, old node name = + * new node name is applied */ - private Map<String, String> nodeNameMapping = new HashMap<String, String>(); + private Map nodeNameMapping = new HashMap(); - private Map<String, String> taskNameMapping = new HashMap<String, String>(); + private Map taskNameMapping = new HashMap(); - public ChangeProcessInstanceVersionCommand() - { + public ChangeProcessInstanceVersionCommand() { } - public ChangeProcessInstanceVersionCommand(long processId, int newVersion) - { + public ChangeProcessInstanceVersionCommand(long processId, int newVersion) { super(); super.setProcessInstanceId(processId); this.newVersion = newVersion; } - + public String getAdditionalToStringInformation() { return ";newVersion=" + newVersion; } - private ProcessDefinition loadNewProcessDefinition(String processName) - { + private ProcessDefinition loadNewProcessDefinition(String processName) { if (newVersion <= 0) return getJbpmContext().getGraphSession().findLatestProcessDefinition(processName); else return getJbpmContext().getGraphSession().findProcessDefinition(processName, newVersion); } - public ProcessInstance execute(ProcessInstance pi) - { + public ProcessInstance execute(ProcessInstance pi) { ProcessDefinition oldDef = pi.getProcessDefinition(); ProcessDefinition newDef = loadNewProcessDefinition(oldDef.getName()); - - if (newDef==null) { - throw new JbpmException("Process definition " + oldDef.getName() + " in version " + newVersion + " not found."); + + if (newDef == null) { + throw new JbpmException("Process definition " + + oldDef.getName() + + " in version " + + newVersion + + " not found."); } - log.debug("Start changing process id " + pi.getId() + " from version " + pi.getProcessDefinition().getVersion() + " to new version " + newDef.getVersion()); + log.debug("Start changing process id " + + pi.getId() + + " from version " + + pi.getProcessDefinition().getVersion() + + " to new version " + + newDef.getVersion()); pi.setProcessDefinition(newDef); changeTokenVersion(pi.getRootToken()); - log.debug("process id " + pi.getId() + " changed to version " + pi.getProcessDefinition().getVersion()); - return pi; + log.debug("process id " + + pi.getId() + + " changed to version " + + pi.getProcessDefinition().getVersion()); + return pi; } - - private ProcessDefinition getNewProcessDefinition(Token t) { + + private ProcessDefinition getNewProcessDefinition(Token t) { return t.getProcessInstance().getProcessDefinition(); } - private void changeTokenVersion(Token token) - { + private void changeTokenVersion(Token token) { ProcessDefinition newDef = getNewProcessDefinition(token); log.debug("change token id " + token.getId() + " to new version " + newDef.getVersion()); @@ -140,166 +136,150 @@ adjustTaskInstancesForToken(token); // change children recursively - if (token.getChildren()!=null) { - Iterator<Token> tokenIter = token.getChildren().values().iterator(); - while (tokenIter.hasNext()) - { - changeTokenVersion(tokenIter.next()); + if (token.getChildren() != null) { + for (Iterator i = token.getChildren().values().iterator(); i.hasNext();) { + changeTokenVersion((Token) i.next()); } } } - private void adjustTaskInstancesForToken(Token token) - { + private void adjustTaskInstancesForToken(Token token) { ProcessDefinition newDef = getNewProcessDefinition(token); - Iterator<TaskInstance> iter = getTasksForToken(token).iterator(); - while (iter.hasNext()) - { - TaskInstance ti = iter.next(); + for (Iterator i = getTasksForToken(token).iterator(); i.hasNext();) { + TaskInstance ti = (TaskInstance) i.next(); // find new task Task oldTask = ti.getTask(); Node oldNode = oldTask.getTaskNode(); - + Task newTask = findReplacementTask(newDef, oldNode, oldTask); ti.setTask(newTask); log.debug("change dependent task-instance with id " + oldTask.getId()); } } - private void adjustTimersForToken(Token token) - { + private void adjustTimersForToken(Token token) { ProcessDefinition newDef = getNewProcessDefinition(token); - List<Job> jobs = getJbpmContext().getJobSession().findJobsByToken(token); - for (Job job : jobs) - { - if (job instanceof Timer) - { + List jobs = getJbpmContext().getJobSession().findJobsByToken(token); + for (Iterator i = jobs.iterator(); i.hasNext();) { + Job job = (Job) i.next(); + if (job instanceof Timer) { // check all timers if connected to a GraphElement - Timer timer = (Timer)job; - if (timer.getGraphElement()!=null) { - + Timer timer = (Timer) job; + if (timer.getGraphElement() != null) { + // and change the reference (take name mappings into account!) if (timer.getGraphElement() instanceof Task) { // change to new task definition - Task oldTask = (Task)timer.getGraphElement(); - TaskNode oldNode = oldTask.getTaskNode(); - timer.setGraphElement( - findReplacementTask(newDef, oldNode, oldTask)); + Task oldTask = (Task) timer.getGraphElement(); + TaskNode oldNode = oldTask.getTaskNode(); + timer.setGraphElement(findReplacementTask(newDef, oldNode, oldTask)); } else { // change to new node GraphElement oldNode = timer.getGraphElement(); // TODO: What with other GraphElements? - timer.setGraphElement( - findReplacementNode(newDef, oldNode)); - } + timer.setGraphElement(findReplacementNode(newDef, oldNode)); + } } } } } - - private Node findReplacementNode(ProcessDefinition newDef, GraphElement oldNode) - { - String name = getReplacementNodeName( oldNode ); + + private Node findReplacementNode(ProcessDefinition newDef, GraphElement oldNode) { + String name = getReplacementNodeName(oldNode); Node newNode = newDef.findNode(name); - if (newNode == null) - { + if (newNode == null) { throw new JbpmException("node with name '" + name + "' not found in new process definition"); } return newNode; } - private Task findReplacementTask(ProcessDefinition newDef, Node oldNode, Task oldTask) - { - String replacementTaskName = getReplacementTaskName( oldTask ); + private Task findReplacementTask(ProcessDefinition newDef, Node oldNode, Task oldTask) { + String replacementTaskName = getReplacementTaskName(oldTask); Node newTaskNode = findReplacementNode(newDef, oldNode); - + Query q = getJbpmContext().getSession().getNamedQuery("TaskMgmtSession.findTaskForNode"); q.setString("taskName", replacementTaskName); q.setLong("taskNodeId", newTaskNode.getId()); - Task newTask = (Task)q.uniqueResult(); - if (newTask == null) - { - throw new JbpmException("Task '" + replacementTaskName + "' for node '" + newTaskNode.getName() + "' not found in new process definition"); + Task newTask = (Task) q.uniqueResult(); + if (newTask == null) { + throw new JbpmException("Task '" + + replacementTaskName + + "' for node '" + + newTaskNode.getName() + + "' not found in new process definition"); } return newTask; } /** * @param oldNode - * @return the name of the new node (given in the map or return default value, which is the old node name) + * @return the name of the new node (given in the map or return default value, which is the old + * node name) */ - private String getReplacementNodeName(GraphElement oldNode) - { - String oldName = (oldNode instanceof Node ? ((Node)oldNode).getFullyQualifiedName() : oldNode.getName()); - if (nodeNameMapping.containsKey(oldName)) - { - return (String)nodeNameMapping.get(oldName); + private String getReplacementNodeName(GraphElement oldNode) { + String oldName = (oldNode instanceof Node ? ((Node) oldNode).getFullyQualifiedName() + : oldNode.getName()); + if (nodeNameMapping.containsKey(oldName)) { + return (String) nodeNameMapping.get(oldName); } // return new node name = old node name as default return oldName; } - private String getReplacementTaskName(Task oldTask) - { + private String getReplacementTaskName(Task oldTask) { String oldName = oldTask.getName(); - if (taskNameMapping.containsKey(oldName)) - { - return (String)taskNameMapping.get(oldName); + if (taskNameMapping.containsKey(oldName)) { + return (String) taskNameMapping.get(oldName); } // return new node name = old node name as default return oldName; } /** - * We may still have open tasks, even though their parent tokens have been ended. So we'll simply get all tasks from - * this process instance and cancel them if they are still active. - * + * We may still have open tasks, even though their parent tokens have been ended. So we'll simply + * get all tasks from this process instance and cancel them if they are still active. */ - private List getTasksForToken(Token token) - { - Query query = getJbpmContext().getSession().getNamedQuery("TaskMgmtSession.findTaskInstancesByTokenId"); + private List getTasksForToken(Token token) { + Query query = getJbpmContext().getSession().getNamedQuery( + "TaskMgmtSession.findTaskInstancesByTokenId"); query.setLong("tokenId", token.getId()); return query.list(); } - public Map getNodeNameMapping() - { + public Map getNodeNameMapping() { return nodeNameMapping; } - - public void setNodeNameMapping(Map<String, String> nameMapping) - { + + public void setNodeNameMapping(Map nameMapping) { if (nameMapping == null) { - this.nodeNameMapping = new HashMap<String, String>(); - } else { + this.nodeNameMapping = new HashMap(); + } + else { this.nodeNameMapping = nameMapping; } } - public int getNewVersion() - { + public int getNewVersion() { return newVersion; } - public void setNewVersion(int newVersion) - { + public void setNewVersion(int newVersion) { this.newVersion = newVersion; } - - public Map getTaskNameMapping() - { + + public Map getTaskNameMapping() { return taskNameMapping; } - public void setTaskNameMapping(Map<String, String> nameMapping) - { + public void setTaskNameMapping(Map nameMapping) { if (nameMapping == null) { - this.taskNameMapping = new HashMap<String, String>(); - } else { + this.taskNameMapping = new HashMap(); + } + else { this.taskNameMapping = nameMapping; } } @@ -307,9 +287,8 @@ /** * @deprecated use getProcessInstanceId instead */ - public long getProcessId() - { - if (getProcessInstanceIds()!=null && getProcessInstanceIds().length>0) + public long getProcessId() { + if (getProcessInstanceIds() != null && getProcessInstanceIds().length > 0) return getProcessInstanceIds()[0]; else return 0; @@ -317,17 +296,15 @@ /** * @deprecated use setProcessInstanceId instead - */ - public void setProcessId(long processId) - { + */ + public void setProcessId(long processId) { super.setProcessInstanceId(processId); } /** * @deprecated use getNodeNameMapping instead */ - public Map getNameMapping() - { + public Map getNameMapping() { return getNodeNameMapping(); } @@ -340,40 +317,37 @@ // methods for fluent programming - public ChangeProcessInstanceVersionCommand nodeNameMapping(Map<String, String> nameMapping) - { + public ChangeProcessInstanceVersionCommand nodeNameMapping(Map nameMapping) { setNodeNameMapping(nameMapping); return this; } - public ChangeProcessInstanceVersionCommand newVersion(int newVersion) - { + public ChangeProcessInstanceVersionCommand newVersion(int newVersion) { setNewVersion(newVersion); return this; } - public ChangeProcessInstanceVersionCommand taskNameMapping(Map<String, String> nameMapping) - { + public ChangeProcessInstanceVersionCommand taskNameMapping(Map nameMapping) { setTaskNameMapping(nameMapping); return this; - } - - public ChangeProcessInstanceVersionCommand nodeNameMappingAdd(String oldNodeName, String newNodeName) - { + } + + public ChangeProcessInstanceVersionCommand nodeNameMappingAdd(String oldNodeName, + String newNodeName) { if (nodeNameMapping == null) { - this.nodeNameMapping = new HashMap<String, String>(); + this.nodeNameMapping = new HashMap(); } - + this.nodeNameMapping.put(oldNodeName, newNodeName); return this; } - public ChangeProcessInstanceVersionCommand taskNameMappingAdd(String oldTaskName, String newNodeName) - { + public ChangeProcessInstanceVersionCommand taskNameMappingAdd(String oldTaskName, + String newNodeName) { if (taskNameMapping == null) { - this.taskNameMapping = new HashMap<String, String>(); + this.taskNameMapping = new HashMap(); } - + this.taskNameMapping.put(oldTaskName, newNodeName); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CompositeCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CompositeCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/CompositeCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -7,32 +7,27 @@ import org.jbpm.JbpmContext; import org.jbpm.JbpmException; +import org.jbpm.util.ClassUtil; -public class CompositeCommand implements Command -{ +public class CompositeCommand implements Command { private static final long serialVersionUID = 1L; List commands = null; - public CompositeCommand(List commands) - { + public CompositeCommand(List commands) { this.commands = commands; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { List results = null; - if (commands != null) - { + if (commands != null) { Object lastResult = null; results = new ArrayList(commands.size()); Iterator iter = commands.iterator(); - while (iter.hasNext()) - { - Command command = (Command)iter.next(); - if (lastResult != null) - { + while (iter.hasNext()) { + Command command = (Command) iter.next(); + if (lastResult != null) { tryToInject(lastResult, command); } lastResult = command.execute(jbpmContext); @@ -42,33 +37,27 @@ return results; } - protected void tryToInject(Object lastResult, Command command) - { + protected void tryToInject(Object lastResult, Command command) { Field field = findField(lastResult.getClass()); - if (field != null) - { + if (field != null) { field.setAccessible(true); - try - { + try { field.set(command, lastResult); } - catch (Exception e) - { + catch (Exception e) { throw new JbpmException("couldn't propagate composite command context", e); } } } - protected Field findField(Class clazz) - { + protected Field findField(Class clazz) { Field field = null; int i = 0; Field[] fields = clazz.getDeclaredFields(); - while ((i < fields.length) && (field == null)) - { + while ((i < fields.length) && (field == null)) { Field candidate = fields[i]; - if ((candidate.getType().isAssignableFrom(clazz)) && (candidate.getName().startsWith("previous"))) - { + if ((candidate.getType().isAssignableFrom(clazz)) + && (candidate.getName().startsWith("previous"))) { field = candidate; } i++; @@ -76,10 +65,8 @@ return field; } - @Override - public String toString() - { - return this.getClass().getSimpleName() + " consists of (" + commands + ")"; + public String toString() { + return ClassUtil.getSimpleName(getClass()) + commands; } - + } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/DeleteProcessDefinitionCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/DeleteProcessDefinitionCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/DeleteProcessDefinitionCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -22,57 +22,49 @@ package org.jbpm.command; import org.jbpm.JbpmContext; +import org.jbpm.util.ClassUtil; /** * Delete a proces definition by ID * * @author Heiko.Braun <heiko.braun(a)jboss.com&gt; */ -public class DeleteProcessDefinitionCommand extends AbstractGetObjectBaseCommand -{ +public class DeleteProcessDefinitionCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -1908847549444051495L; private long id; - public DeleteProcessDefinitionCommand() - { + public DeleteProcessDefinitionCommand() { } - public DeleteProcessDefinitionCommand(long id) - { + public DeleteProcessDefinitionCommand(long id) { super(); this.id = id; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(id); return Boolean.TRUE; } - @Override - public String toString() - { - return this.getClass().getSimpleName() + " [processDefinition.id=" + id + "]"; + public String toString() { + return ClassUtil.getSimpleName(getClass()) + " [processDefinition.id=" + id + "]"; } - public long getId() - { + public long getId() { return id; } - public void setId(long id) - { + public void setId(long id) { this.id = id; } - + // methods for fluent programming - public DeleteProcessDefinitionCommand id(long id) - { + public DeleteProcessDefinitionCommand id(long id) { setId(id); return this; } - + } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -7,8 +7,7 @@ * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetProcessDefinitionCommand extends AbstractGetObjectBaseCommand -{ +public class GetProcessDefinitionCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -1908847549444051495L; @@ -16,69 +15,58 @@ private String name; - public GetProcessDefinitionCommand() - { + public GetProcessDefinitionCommand() { } - public GetProcessDefinitionCommand(String name) - { + public GetProcessDefinitionCommand(String name) { super(); this.name = name; } - public GetProcessDefinitionCommand(String name, int version) - { + public GetProcessDefinitionCommand(String name, int version) { super(); this.version = version; this.name = name; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { if (version >= 0) - return retrieveProcessDefinition(jbpmContext.getGraphSession().findProcessDefinition(name, version)); + return retrieveProcessDefinition(jbpmContext.getGraphSession().findProcessDefinition(name, + version)); else - return retrieveProcessDefinition(jbpmContext.getGraphSession().findLatestProcessDefinition(name)); + return retrieveProcessDefinition(jbpmContext.getGraphSession().findLatestProcessDefinition( + name)); } - public String getName() - { + public String getName() { return name; } - public void setName(String name) - { + public void setName(String name) { this.name = name; } - public int getVersion() - { + public int getVersion() { return version; } - public void setVersion(int version) - { + public void setVersion(int version) { this.version = version; } - @Override - public String getAdditionalToStringInformation() - { - return "name=" + name - + ";version=" + version; - } - + public String getAdditionalToStringInformation() { + return "name=" + name + ";version=" + version; + } + // methods for fluent programming - public GetProcessDefinitionCommand version(int version) - { + public GetProcessDefinitionCommand version(int version) { setVersion(version); return this; } - - public GetProcessDefinitionCommand name(String name) - { + + public GetProcessDefinitionCommand name(String name) { setName(name); - return this; + return this; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionsCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionsCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessDefinitionsCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -11,60 +11,51 @@ * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetProcessDefinitionsCommand extends AbstractGetObjectBaseCommand -{ +public class GetProcessDefinitionsCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -1908847549444051495L; private boolean onlyLatest = true; - public GetProcessDefinitionsCommand() - { + public GetProcessDefinitionsCommand() { } - public GetProcessDefinitionsCommand(boolean onlyLatest) - { + public GetProcessDefinitionsCommand(boolean onlyLatest) { this.onlyLatest = onlyLatest; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { setJbpmContext(jbpmContext); - List result = (onlyLatest ? jbpmContext.getGraphSession().findLatestProcessDefinitions() : jbpmContext.getGraphSession().findAllProcessDefinitions()); + List result = (onlyLatest ? jbpmContext.getGraphSession().findLatestProcessDefinitions() + : jbpmContext.getGraphSession().findAllProcessDefinitions()); /* * traverse and access property if it is missing in the default fetchgroup */ Iterator iter = result.iterator(); - while (iter.hasNext()) - { - ProcessDefinition pd = (ProcessDefinition)iter.next(); + while (iter.hasNext()) { + ProcessDefinition pd = (ProcessDefinition) iter.next(); retrieveProcessDefinition(pd); } return result; } - public boolean isOnlyLatest() - { + public boolean isOnlyLatest() { return onlyLatest; } - public void setOnlyLatest(boolean onlyLatest) - { + public void setOnlyLatest(boolean onlyLatest) { this.onlyLatest = onlyLatest; } - - @Override - public String getAdditionalToStringInformation() - { + + public String getAdditionalToStringInformation() { return "onlyLatest=" + onlyLatest; } // methods for fluent programming - public GetProcessDefinitionsCommand onlyLatest(boolean onlyLatest) - { + public GetProcessDefinitionsCommand onlyLatest(boolean onlyLatest) { setOnlyLatest(onlyLatest); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,13 +4,12 @@ import org.jbpm.graph.exe.ProcessInstance; /** - * This command can retrieve the matching process instances (e.g. for admin client) with the given process-id, token id - * or task-id + * This command can retrieve the matching process instances (e.g. for admin client) with the given + * process-id, token id or task-id * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetProcessInstanceCommand extends AbstractGetObjectBaseCommand -{ +public class GetProcessInstanceCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -8436697080972165601L; @@ -20,23 +19,20 @@ private long taskInstanceId; - public GetProcessInstanceCommand() - { + public GetProcessInstanceCommand() { } - public GetProcessInstanceCommand(long processInstanceId) - { + public GetProcessInstanceCommand(long processInstanceId) { this.processInstanceId = processInstanceId; } - public GetProcessInstanceCommand(long processInstanceId, boolean includeVariables, boolean includeLogs) - { + public GetProcessInstanceCommand(long processInstanceId, boolean includeVariables, + boolean includeLogs) { super(true, true); this.processInstanceId = processInstanceId; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { setJbpmContext(jbpmContext); ProcessInstance processInstance = null; @@ -47,67 +43,58 @@ else if (taskInstanceId != 0) processInstance = jbpmContext.getTaskInstance(taskInstanceId).getProcessInstance(); - if (processInstance != null) - { + if (processInstance != null) { processInstance = retrieveProcessInstance(processInstance); } return processInstance; } - public long getProcessInstanceId() - { + public long getProcessInstanceId() { return processInstanceId; } - public void setProcessInstanceId(long processInstanceId) - { + public void setProcessInstanceId(long processInstanceId) { this.processInstanceId = processInstanceId; } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public long getTokenId() - { + public long getTokenId() { return tokenId; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.tokenId = tokenId; } - @Override - public String getAdditionalToStringInformation() - { - return "processInstanceId=" + processInstanceId - + ";tokenId=" + tokenId - + ";taskInstanceId=" + taskInstanceId; + public String getAdditionalToStringInformation() { + return "processInstanceId=" + + processInstanceId + + ";tokenId=" + + tokenId + + ";taskInstanceId=" + + taskInstanceId; } // methods for fluent programming - public GetProcessInstanceCommand processInstanceId(long processInstanceId) - { + public GetProcessInstanceCommand processInstanceId(long processInstanceId) { setProcessInstanceId(processInstanceId); return this; } - public GetProcessInstanceCommand taskInstanceId(long taskInstanceId) - { + public GetProcessInstanceCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } - public GetProcessInstanceCommand tokenId(long tokenId) - { + public GetProcessInstanceCommand tokenId(long tokenId) { setTokenId(tokenId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceLogCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceLogCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstanceLogCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -9,54 +9,43 @@ import org.jbpm.logging.log.ProcessLog; /** - * Retrieve the <code>org.jbpm.logging.log.ProcessLog</code> for - * the process with the given process-id + * Retrieve the <code>org.jbpm.logging.log.ProcessLog</code> for the process with the given + * process-id returns a map that maps {@link Token}s to {@link List}s. * - * returns a map that maps {@link Token}s to {@link List}s. - * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) - * */ -public class GetProcessInstanceLogCommand extends AbstractBaseCommand -{ +public class GetProcessInstanceLogCommand extends AbstractBaseCommand { private static final long serialVersionUID = -2812852941518870502L; private long processInstanceId; - public GetProcessInstanceLogCommand() - { + public GetProcessInstanceLogCommand() { } - public GetProcessInstanceLogCommand(long processInstanceId) - { + public GetProcessInstanceLogCommand(long processInstanceId) { this.processInstanceId = processInstanceId; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { Map logMap = jbpmContext.getLoggingSession().findLogsByProcessInstance(processInstanceId); return loadLogdFromMap(logMap); } /** - * access everything on all ProcessLog objects, which is not in the default fetch group from hibernate, but needs to - * be accesible from the client - * - * overwrite this method, if you need more details in your client + * access everything on all ProcessLog objects, which is not in the default fetch group from + * hibernate, but needs to be accesible from the client overwrite this method, if you need more + * details in your client */ - protected Map loadLogdFromMap(Map logMap) - { + protected Map loadLogdFromMap(Map logMap) { Iterator iter = logMap.keySet().iterator(); - while (iter.hasNext()) - { - Token t = (Token)iter.next(); + while (iter.hasNext()) { + Token t = (Token) iter.next(); - List logs = (List)logMap.get(t); + List logs = (List) logMap.get(t); Iterator iter2 = logs.iterator(); - while (iter2.hasNext()) - { - ProcessLog pl = (ProcessLog)iter2.next(); + while (iter2.hasNext()) { + ProcessLog pl = (ProcessLog) iter2.next(); // TODO: I am not sure if we need that, write a test for it pl.getActorId(); pl.toString(); @@ -68,39 +57,32 @@ /** * @deprecated use getProcessInstanceId instead */ - public long getProcessId() - { + public long getProcessId() { return processInstanceId; } /** * @deprecated use setProcessInstanceId instead */ - public void setProcessId(long processId) - { + public void setProcessId(long processId) { this.processInstanceId = processId; } - public long getProcessInstanceId() - { + public long getProcessInstanceId() { return processInstanceId; } - public void setProcessInstanceId(long processInstanceId) - { + public void setProcessInstanceId(long processInstanceId) { this.processInstanceId = processInstanceId; } - @Override - public String getAdditionalToStringInformation() - { + public String getAdditionalToStringInformation() { return "processInstanceId=" + processInstanceId; } - + // methods for fluent programming - - public GetProcessInstanceLogCommand processInstanceId(long processInstanceId) - { + + public GetProcessInstanceLogCommand processInstanceId(long processInstanceId) { setProcessInstanceId(processInstanceId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstancesCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstancesCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetProcessInstancesCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,18 +5,17 @@ import java.util.List; import org.hibernate.Query; + import org.jbpm.JbpmContext; import org.jbpm.graph.exe.ProcessInstance; /** - * This command can retrieve all process instances (e.g. for admin client). + * This command can retrieve all process instances (e.g. for admin client). You have the possibility + * to filter the command, therefor use the available attributes * - * You have the possibility to filter the command, therefor use the available attributes - * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetProcessInstancesCommand extends AbstractGetObjectBaseCommand -{ +public class GetProcessInstancesCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -5601050489405283851L; @@ -50,54 +49,46 @@ private transient boolean firstExpression = true; - private String getConcatExpression() - { - if (firstExpression) - { + private String getConcatExpression() { + if (firstExpression) { firstExpression = false; return " where "; } return " and "; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { setJbpmContext(jbpmContext); firstExpression = true; - StringBuffer queryText = new StringBuffer("select pi" + " from org.jbpm.graph.exe.ProcessInstance as pi "); + StringBuffer queryText = new StringBuffer("select pi" + + " from org.jbpm.graph.exe.ProcessInstance as pi "); - if (onlyRunning) - { + if (onlyRunning) { queryText.append(getConcatExpression()).append(" pi.end = null"); } - if (fromStartDate != null) - { + if (fromStartDate != null) { queryText.append(getConcatExpression()).append(" pi.start >= :from "); } - if (untilStartDate != null) - { + if (untilStartDate != null) { queryText.append(getConcatExpression()).append(" pi.start <= :until "); } - if (version != null) - { + if (version != null) { queryText.append(getConcatExpression()).append(" pi.version = :version "); } // name - if (processInstanceId != -1) - { + if (processInstanceId != -1) { queryText.append(getConcatExpression()).append(" pi.processDefinition.id = :processId "); } - else if (processDefinitionName != null && processDefinitionName.length() > 0) - { - queryText.append(getConcatExpression()).append(" pi.processDefinition.name = :processDefinitionName "); + else if (processDefinitionName != null && processDefinitionName.length() > 0) { + queryText.append(getConcatExpression()).append( + " pi.processDefinition.name = :processDefinitionName "); } // TODO: this code only fecthes root tokens, child-tokens has to be // considered too! - if (stateName != null && stateName.length() > 0) - { + if (stateName != null && stateName.length() > 0) { queryText.append(getConcatExpression()).append(" pi.rootToken.node.name = :nodeName "); } @@ -105,31 +96,25 @@ Query query = jbpmContext.getSession().createQuery(queryText.toString()); - if (fromStartDate != null) - { + if (fromStartDate != null) { query.setTimestamp("from", fromStartDate); } - if (untilStartDate != null) - { + if (untilStartDate != null) { query.setTimestamp("until", untilStartDate); } - if (processInstanceId != -1) - { + if (processInstanceId != -1) { query.setLong("processId", processInstanceId); } - if (processDefinitionName != null && processDefinitionName.length() > 0) - { + if (processDefinitionName != null && processDefinitionName.length() > 0) { query.setString("processDefinitionName", processDefinitionName); } - if (stateName != null && stateName.length() > 0) - { + if (stateName != null && stateName.length() > 0) { query.setString("nodeName", stateName); } - if (version != null) - { + if (version != null) { query.setString("version", version); } @@ -137,175 +122,152 @@ } /** - * access everything on all processInstance objects, which is not in the default fetch group from hibernate, but needs - * to be accesible from the client - * - * overwrite this, if you need more details in your client + * access everything on all processInstance objects, which is not in the default fetch group from + * hibernate, but needs to be accesible from the client overwrite this, if you need more details + * in your client */ - public List retrieveProcessInstanceDetails(List processInstanceList) - { + public List retrieveProcessInstanceDetails(List processInstanceList) { Iterator it = processInstanceList.iterator(); - while (it.hasNext()) - { - retrieveProcessInstance((ProcessInstance)it.next()); + while (it.hasNext()) { + retrieveProcessInstance((ProcessInstance) it.next()); } return processInstanceList; } - public Date getFromStartDate() - { + public Date getFromStartDate() { return fromStartDate; } - public void setFromStartDate(Date fromStartDate) - { + public void setFromStartDate(Date fromStartDate) { this.fromStartDate = fromStartDate; } - public boolean isOnlyRunning() - { + public boolean isOnlyRunning() { return onlyRunning; } - public void setOnlyRunning(boolean onlyRunning) - { + public void setOnlyRunning(boolean onlyRunning) { this.onlyRunning = onlyRunning; } /** * @deprecated */ - public String getProcessName() - { + public String getProcessName() { return processDefinitionName; } /** * @deprecated */ - public void setProcessName(String processName) - { + public void setProcessName(String processName) { this.processDefinitionName = processName; } - public String getProcessDefinitionName() - { + public String getProcessDefinitionName() { return processDefinitionName; } - public void setProcessDefinitionName(String processName) - { + public void setProcessDefinitionName(String processName) { this.processDefinitionName = processName; } - public String getStateName() - { + public String getStateName() { return stateName; } - public void setStateName(String stateName) - { + public void setStateName(String stateName) { this.stateName = stateName; } - public Date getUntilStartDate() - { + public Date getUntilStartDate() { return untilStartDate; } - public void setUntilStartDate(Date untilStartDate) - { + public void setUntilStartDate(Date untilStartDate) { this.untilStartDate = untilStartDate; } - public String getVersion() - { + public String getVersion() { return version; } - public void setVersion(String version) - { + public void setVersion(String version) { this.version = version; } - public long getProcessInstanceId() - { + public long getProcessInstanceId() { return processInstanceId; } - public void setProcessInstanceId(long processId) - { + public void setProcessInstanceId(long processId) { this.processInstanceId = processId; } /** * @deprecated */ - public long getProcessId() - { + public long getProcessId() { return processInstanceId; } /** * @deprecated */ - public void setProcessId(long processId) - { + public void setProcessId(long processId) { this.processInstanceId = processId; } - @Override - public String getAdditionalToStringInformation() - { - return "processInstanceId=" + processInstanceId - + ";processDefinitionName=" + processDefinitionName - + ";version=" + version - + ";stateName=" + stateName - + ";fromStartDate=" + fromStartDate - + ";untilStartDate=" + untilStartDate - + ";onlyRunning=" + onlyRunning; + public String getAdditionalToStringInformation() { + return "processInstanceId=" + + processInstanceId + + ";processDefinitionName=" + + processDefinitionName + + ";version=" + + version + + ";stateName=" + + stateName + + ";fromStartDate=" + + fromStartDate + + ";untilStartDate=" + + untilStartDate + + ";onlyRunning=" + + onlyRunning; } - + // methods for fluent programming - public GetProcessInstancesCommand fromStartDate(Date fromStartDate) - { + public GetProcessInstancesCommand fromStartDate(Date fromStartDate) { setFromStartDate(fromStartDate); return this; } - public GetProcessInstancesCommand onlyRunning(boolean onlyRunning) - { + public GetProcessInstancesCommand onlyRunning(boolean onlyRunning) { setOnlyRunning(onlyRunning); return this; } - public GetProcessInstancesCommand processDefinitionName(String processName) - { + public GetProcessInstancesCommand processDefinitionName(String processName) { setProcessDefinitionName(processName); return this; } - public GetProcessInstancesCommand stateName(String stateName) - { + public GetProcessInstancesCommand stateName(String stateName) { setStateName(stateName); return this; } - public GetProcessInstancesCommand untilStartDate(Date untilStartDate) - { + public GetProcessInstancesCommand untilStartDate(Date untilStartDate) { setUntilStartDate(untilStartDate); return this; } - public GetProcessInstancesCommand version(String version) - { + public GetProcessInstancesCommand version(String version) { setVersion(version); return this; } - public GetProcessInstancesCommand processInstanceId(long processId) - { + public GetProcessInstancesCommand processInstanceId(long processId) { setProcessInstanceId(processId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -7,13 +7,12 @@ import org.jbpm.taskmgmt.exe.TaskInstance; /** - * This command can retrieve a task instance (for client) with the given task-id or the token-id (then, the first task - * for the token is searched) + * This command can retrieve a task instance (for client) with the given task-id or the token-id + * (then, the first task for the token is searched) * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetTaskInstanceCommand extends AbstractGetObjectBaseCommand -{ +public class GetTaskInstanceCommand extends AbstractGetObjectBaseCommand { private static final long serialVersionUID = -8436697080972165601L; @@ -30,63 +29,51 @@ private long processInstanceId; /** - * NOT YET USED! JUST TO DOCUMENT THE IDEA... - * - * result of the Command: a gui element, configured via the TaskController. Can be used to identify a Swing-Class, - * JSF-Site, ... + * NOT YET USED! JUST TO DOCUMENT THE IDEA... result of the Command: a gui element, configured via + * the TaskController. Can be used to identify a Swing-Class, JSF-Site, ... */ private String configuredGuiElement; - public GetTaskInstanceCommand() - { + public GetTaskInstanceCommand() { } - public GetTaskInstanceCommand(long taskInstanceId) - { + public GetTaskInstanceCommand(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public GetTaskInstanceCommand(long taskInstanceId, boolean includeVariables, boolean includeLogs) - { + public GetTaskInstanceCommand(long taskInstanceId, boolean includeVariables, boolean includeLogs) { super(includeVariables, includeLogs); this.taskInstanceId = taskInstanceId; } - public GetTaskInstanceCommand(long taskInstanceId, String[] variablesToInclude) - { + public GetTaskInstanceCommand(long taskInstanceId, String[] variablesToInclude) { super(variablesToInclude); this.taskInstanceId = taskInstanceId; } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { - if (taskInstanceId > 0) - { + if (taskInstanceId > 0) { TaskInstance taskInstance = jbpmContext.getTaskInstance(taskInstanceId); - if (taskInstance != null) - { + if (taskInstance != null) { retrieveTaskInstanceDetails(taskInstance); } return taskInstance; } - else if (tokenId > 0) - { + else if (tokenId > 0) { List result = jbpmContext.getTaskMgmtSession().findTaskInstancesByToken(tokenId); - for (Iterator iter = result.iterator(); iter.hasNext();) - { - TaskInstance ti = (TaskInstance)iter.next(); + for (Iterator iter = result.iterator(); iter.hasNext();) { + TaskInstance ti = (TaskInstance) iter.next(); retrieveTaskInstanceDetails(ti); } return result; } - else if (processInstanceId > 0) - { - List result = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(jbpmContext.getProcessInstance(processInstanceId)); - for (Iterator iter = result.iterator(); iter.hasNext();) - { - TaskInstance ti = (TaskInstance)iter.next(); + else if (processInstanceId > 0) { + List result = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance( + jbpmContext.getProcessInstance(processInstanceId)); + for (Iterator iter = result.iterator(); iter.hasNext();) { + TaskInstance ti = (TaskInstance) iter.next(); retrieveTaskInstanceDetails(ti); } return result; @@ -95,60 +82,52 @@ return null; } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public long getTokenId() - { + public long getTokenId() { return tokenId; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.tokenId = tokenId; } - public long getProcessInstanceId() - { + public long getProcessInstanceId() { return processInstanceId; } - public void setProcessInstanceId(long processInstanceId) - { + public void setProcessInstanceId(long processInstanceId) { this.processInstanceId = processInstanceId; } - @Override - public String getAdditionalToStringInformation() - { - return "processInstanceId=" + processInstanceId - + ";tokenId=" + tokenId - + ";taskInstanceId=" + taskInstanceId; + public String getAdditionalToStringInformation() { + return "processInstanceId=" + + processInstanceId + + ";tokenId=" + + tokenId + + ";taskInstanceId=" + + taskInstanceId; } - + // methods for fluent programming - public GetTaskInstanceCommand taskInstanceId(long taskInstanceId) - { + public GetTaskInstanceCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } - public GetTaskInstanceCommand tokenId(long tokenId) - { + public GetTaskInstanceCommand tokenId(long tokenId) { setTokenId(tokenId); - return this; + return this; } - public GetTaskInstanceCommand processInstanceId(long processInstanceId) - { + public GetTaskInstanceCommand processInstanceId(long processInstanceId) { setProcessInstanceId(processInstanceId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskListCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskListCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/GetTaskListCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -7,20 +7,19 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.taskmgmt.exe.TaskInstance; +import org.jbpm.util.ArrayUtil; /** - * return a {@link java.util.List} of {@link org.jbpm.taskmgmt.exe.TaskInstance}s for the given actor(s). + * return a {@link java.util.List} of {@link org.jbpm.taskmgmt.exe.TaskInstance}s for the given + * actor(s). if no actor is used, the current authenticated user is taken as actor. for all actors + * it is checked, if they are pooled or assigned actor! * - * if no actor is used, the current authenticated user is taken as actor. - * - * for all actors it is checked, if they are pooled or assigned actor! - * * @author Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class GetTaskListCommand extends AbstractGetObjectBaseCommand implements Command -{ +public class GetTaskListCommand extends AbstractGetObjectBaseCommand implements Command { private static final long serialVersionUID = -1627380259541998349L; @@ -28,34 +27,28 @@ private String[] actor; - public GetTaskListCommand(String[] actor) - { + public GetTaskListCommand(String[] actor) { setActor(actor); } - public GetTaskListCommand(String actor, boolean includeVariables) - { + public GetTaskListCommand(String actor, boolean includeVariables) { super(includeVariables, false); setActor(actor); } - public GetTaskListCommand(String actor, String[] variablesToInclude) - { + public GetTaskListCommand(String actor, String[] variablesToInclude) { super(variablesToInclude); setActor(actor); } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { setJbpmContext(jbpmContext); List result = null; if (actor == null || actor.length == 0) result = jbpmContext.getTaskList(); - else - { + else { result = new ArrayList(); - for (int i = 0; i < actor.length; i++) - { + for (int i = 0; i < actor.length; i++) { result.addAll(jbpmContext.getTaskList(actor[i])); } result.addAll(jbpmContext.getGroupTaskList(Arrays.asList(actor))); @@ -65,51 +58,41 @@ } /** - * access everything on all TaskInstance objects, which is not in the default fetch group from hibernate, but needs to - * be accesible from the client - * - * overwrite this, if you need more details in your client + * access everything on all TaskInstance objects, which is not in the default fetch group from + * hibernate, but needs to be accesible from the client overwrite this, if you need more details + * in your client */ - public List retrieveTaskInstanceDetails(List taskInstanceList) - { - for (Iterator iter = taskInstanceList.iterator(); iter.hasNext();) - { - retrieveTaskInstanceDetails((TaskInstance)iter.next()); + public List retrieveTaskInstanceDetails(List taskInstanceList) { + for (Iterator iter = taskInstanceList.iterator(); iter.hasNext();) { + retrieveTaskInstanceDetails((TaskInstance) iter.next()); } return taskInstanceList; } - public String[] getActor() - { + public String[] getActor() { return actor; } - public void setActor(String actor) - { + public void setActor(String actor) { this.actor = new String[] { actor }; } - public void setActor(String[] actor) - { + public void setActor(String[] actor) { this.actor = actor; } - - @Override - public String getAdditionalToStringInformation() - { - return "actors=" + Arrays.toString( actor ); + + public String getAdditionalToStringInformation() { + return "actors=" + ArrayUtil.toString(actor); } // methods for fluent programming - public GetTaskListCommand actor(String actor) - { + public GetTaskListCommand actor(String actor) { this.actor = new String[] { actor }; return this; } - public GetTaskListCommand actor(String[] actor) - { + public GetTaskListCommand actor(String[] actor) { this.actor = actor; return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/NewProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/NewProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/NewProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,14 +30,13 @@ import org.jbpm.graph.exe.ProcessInstance; /** - * Graph command to start a new process and create a task instance if the start node has a start task definition. + * Graph command to start a new process and create a task instance if the start node has a start + * task definition. The result of this command, if requested, is a {@link Long} value containing the + * process instance id. * - * The result of this command, if requested, is a {@link Long} value containing the process instance id. - * * @author Jim Rigsbee, Tom Baeyens, Bernd Ruecker */ -public class NewProcessInstanceCommand extends AbstractBaseCommand -{ +public class NewProcessInstanceCommand extends AbstractBaseCommand { private static final long serialVersionUID = 1L; @@ -52,12 +51,10 @@ private String key; - public NewProcessInstanceCommand() - { + public NewProcessInstanceCommand() { } - public NewProcessInstanceCommand(String processDefinitionName) - { + public NewProcessInstanceCommand(String processDefinitionName) { this.processDefinitionName = processDefinitionName; } @@ -66,47 +63,39 @@ * * @throws Exception */ - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { - if (actorId != null) - { + if (actorId != null) { jbpmContext.setActorId(actorId); } ProcessInstance processInstance = null; - if (processDefinitionName != null) - { + if (processDefinitionName != null) { processInstance = jbpmContext.newProcessInstance(processDefinitionName); } - else - { - ProcessDefinition processDefinition = jbpmContext.getGraphSession().loadProcessDefinition(processDefinitionId); + else { + ProcessDefinition processDefinition = jbpmContext.getGraphSession().loadProcessDefinition( + processDefinitionId); processInstance = new ProcessInstance(processDefinition); } - if (key != null) - { + if (key != null) { processInstance.setKey(key); } Object result = null; - if (createStartTask) - { + if (createStartTask) { result = processInstance.getTaskMgmtInstance().createStartTaskInstance(); } - else - { + else { result = processInstance; } - if (variables != null) - { + if (variables != null) { ContextInstance contextInstance = processInstance.getContextInstance(); Iterator iter = variables.keySet().iterator(); - while (iter.hasNext()) - { - String variableName = (String)iter.next(); + while (iter.hasNext()) { + String variableName = (String) iter.next(); contextInstance.setVariable(variableName, variables.get(variableName)); } } @@ -116,142 +105,124 @@ return result; } - public String getActorId() - { + public String getActorId() { return actorId; } - public void setActorId(String actorId) - { + public void setActorId(String actorId) { this.actorId = actorId; } - public long getProcessDefinitionId() - { + public long getProcessDefinitionId() { return processDefinitionId; } - public void setProcessDefinitionId(long processId) - { + public void setProcessDefinitionId(long processId) { this.processDefinitionId = processId; } /** * @deprecated use getProcessDefinitionId instead */ - public long getProcessId() - { + public long getProcessId() { return processDefinitionId; } /** * @deprecated use setProcessDefinitionId instead */ - public void setProcessId(long processId) - { + public void setProcessId(long processId) { this.processDefinitionId = processId; } /** * @deprecated use getProcessDefinitionName instead */ - public String getProcessName() - { + public String getProcessName() { return processDefinitionName; } /** * @deprecated use setProcessDefinitionName instead */ - public void setProcessName(String processName) - { + public void setProcessName(String processName) { this.processDefinitionName = processName; } - - public boolean isCreateStartTask() - { + + public boolean isCreateStartTask() { return createStartTask; } - public void setCreateStartTask(boolean createStartTask) - { + public void setCreateStartTask(boolean createStartTask) { this.createStartTask = createStartTask; } - public Map getVariables() - { + public Map getVariables() { return variables; } - public String getProcessDefinitionName() - { + + public String getProcessDefinitionName() { return processDefinitionName; } - public void setProcessDefinitionName(String processDefinitionName) - { + public void setProcessDefinitionName(String processDefinitionName) { this.processDefinitionName = processDefinitionName; } - - public void setVariables(Map variables) - { + + public void setVariables(Map variables) { this.variables = variables; } - public String getKey() - { + public String getKey() { return key; } - public void setKey(String key) - { + public void setKey(String key) { this.key = key; } - - @Override - public String getAdditionalToStringInformation() - { - return "processDefinitionId=" + processDefinitionId - + ";processDefinitionName=" + processDefinitionName - + ";createStartTask=" + createStartTask - + ";businessKey=" + key - // TODO: not sure how this is - + ";variables=" + variables; + + public String getAdditionalToStringInformation() { + return "processDefinitionId=" + + processDefinitionId + + ";processDefinitionName=" + + processDefinitionName + + ";createStartTask=" + + createStartTask + + ";businessKey=" + + key + // TODO: not sure how this is + + ";variables=" + + variables; } - + // methods for fluent programming - - public NewProcessInstanceCommand actorId(String actorId) - { + + public NewProcessInstanceCommand actorId(String actorId) { setActorId(actorId); return this; } - public NewProcessInstanceCommand processDefinitionId(long processId) - { + public NewProcessInstanceCommand processDefinitionId(long processId) { setProcessDefinitionId(processId); return this; } - public NewProcessInstanceCommand processDefinitionName(String processName) - { + public NewProcessInstanceCommand processDefinitionName(String processName) { setProcessDefinitionName(processName); return this; } - public NewProcessInstanceCommand createStartTask(boolean createStartTask) - { + public NewProcessInstanceCommand createStartTask(boolean createStartTask) { setCreateStartTask(createStartTask); return this; } - public NewProcessInstanceCommand variables(Map variables) - { + public NewProcessInstanceCommand variables(Map variables) { setVariables(variables); return this; } - public NewProcessInstanceCommand key(String key) - { + public NewProcessInstanceCommand key(String key) { setKey(key); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,18 +4,16 @@ /** * Resume the specified {@link ProcessInstance}(s). See {@link AbstractProcessInstanceBaseCommand} - * to check possibilities to specify {@link ProcessInstance}(s). + * to check possibilities to specify {@link ProcessInstance}(s). * * @author bernd.ruecker(a)camunda.com */ public class ResumeProcessInstanceCommand extends AbstractProcessInstanceBaseCommand { - + private static final long serialVersionUID = 1L; - @Override - public ProcessInstance execute(ProcessInstance processInstance) - { + public ProcessInstance execute(ProcessInstance processInstance) { processInstance.resume(); - return processInstance; + return processInstance; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeTokenCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeTokenCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/ResumeTokenCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -3,8 +3,8 @@ import org.jbpm.graph.exe.Token; /** - * Resume the specified {@link Token}(s). See {@link AbstractTokenBaseCommand} - * to check possibilities to specify {@link Token}(s). + * Resume the specified {@link Token}(s). See {@link AbstractTokenBaseCommand} to check + * possibilities to specify {@link Token}(s). * * @author bernd.ruecker(a)camunda.com */ @@ -12,9 +12,7 @@ private static final long serialVersionUID = 1L; - @Override - public Token execute(Token token) - { + public Object execute(Token token) { token.resume(); return token; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SignalCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SignalCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SignalCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -25,6 +25,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.graph.exe.ProcessInstance; @@ -35,8 +36,7 @@ * * @author ??, Bernd Ruecker */ -public class SignalCommand extends AbstractBaseCommand -{ +public class SignalCommand extends AbstractBaseCommand { private static final long serialVersionUID = 1L; private static Log log = LogFactory.getLog(SignalCommand.class); @@ -46,7 +46,8 @@ private String transitionName = null; /** - * if given, it is checked if the state is as expected. If not, a exception is thrown Ignored if null + * if given, it is checked if the state is as expected. If not, a exception is thrown Ignored if + * null */ private String expectedStateName = null; @@ -56,138 +57,121 @@ private Map variables; - public SignalCommand() - { + public SignalCommand() { } - public SignalCommand(long tokenId, String transitionName) - { + public SignalCommand(long tokenId, String transitionName) { this.tokenId = tokenId; this.transitionName = transitionName; } - public Object execute(JbpmContext jbpmContext) - { + public Object execute(JbpmContext jbpmContext) { log.debug("executing " + this); - if (previousProcessInstance != null) - { + if (previousProcessInstance != null) { if (variables != null && variables.size() > 0) previousProcessInstance.getContextInstance().addVariables(variables); - if (transitionName == null) - { + if (transitionName == null) { previousProcessInstance.signal(); } - else - { + else { previousProcessInstance.signal(transitionName); } return previousProcessInstance.getRootToken(); } - else - { + else { Token token = getToken(jbpmContext); if (expectedStateName != null && !expectedStateName.equals(token.getNode().getName())) - throw new JbpmException("token is not in expected state '" + expectedStateName + "' but in '" + token.getNode().getName() + "'"); + throw new JbpmException("token is not in expected state '" + + expectedStateName + + "' but in '" + + token.getNode().getName() + + "'"); if (variables != null && variables.size() > 0) token.getProcessInstance().getContextInstance().addVariables(variables); - if (transitionName == null) - { + if (transitionName == null) { token.signal(); } - else - { + else { token.signal(transitionName); } return token; } } - protected Token getToken(JbpmContext jbpmContext) - { - if (previousToken != null) - { + protected Token getToken(JbpmContext jbpmContext) { + if (previousToken != null) { return previousToken; } return jbpmContext.loadTokenForUpdate(tokenId); } - public long getTokenId() - { + public long getTokenId() { return tokenId; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.tokenId = tokenId; } - public String getTransitionName() - { + public String getTransitionName() { return transitionName; } - public void setTransitionName(String transitionName) - { + public void setTransitionName(String transitionName) { this.transitionName = transitionName; } - public Map getVariables() - { + public Map getVariables() { return variables; } - public void setVariables(Map variables) - { + public void setVariables(Map variables) { this.variables = variables; } - public String getExpectedStateName() - { + public String getExpectedStateName() { return expectedStateName; } - public void setExpectedStateName(String expectedStateName) - { + public void setExpectedStateName(String expectedStateName) { this.expectedStateName = expectedStateName; } - - @Override - public String getAdditionalToStringInformation() - { - return "tokenId=" + tokenId - + ";transitionName=" + transitionName - + ";processDefinitionName=" + expectedStateName - // TODO: not sure how this is - + ";variables=" + variables; - } + public String getAdditionalToStringInformation() { + return "tokenId=" + + tokenId + + ";transitionName=" + + transitionName + + ";processDefinitionName=" + + expectedStateName + // TODO: not sure how this is + + ";variables=" + + variables; + } + // methods for fluent programming - public SignalCommand tokenId(long tokenId) - { + public SignalCommand tokenId(long tokenId) { setTokenId(tokenId); return this; } - public SignalCommand transitionName(String transitionName) - { + public SignalCommand transitionName(String transitionName) { setTransitionName(transitionName); return this; } - public SignalCommand variables(Map variables) - { + public SignalCommand variables(Map variables) { setVariables(variables); return this; } - public SignalCommand expectedStateName(String expectedStateName) - { + public SignalCommand expectedStateName(String expectedStateName) { setExpectedStateName(expectedStateName); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,14 +5,12 @@ /** * Graph command to start a new process and signal it immidiatly. The transition named in - * <code>startTransitionName</code> is used (or the default transition if it is null). + * <code>startTransitionName</code> is used (or the default transition if it is null). The result of + * this command, if requested, is a {@link Long} value containing the process instance id. * - * The result of this command, if requested, is a {@link Long} value containing the process instance id. - * * @author Jim Rigsbee, Tom Baeyens, Bernd Ruecker */ -public class StartProcessInstanceCommand extends NewProcessInstanceCommand implements Command -{ +public class StartProcessInstanceCommand extends NewProcessInstanceCommand implements Command { private static final long serialVersionUID = -2428234069404269048L; @@ -21,12 +19,10 @@ */ private String startTransitionName = null; - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { Object object = super.execute(jbpmContext); - if (object instanceof ProcessInstance) - { - ProcessInstance processInstance = (ProcessInstance)object; + if (object instanceof ProcessInstance) { + ProcessInstance processInstance = (ProcessInstance) object; if (startTransitionName == null || startTransitionName.length() == 0) processInstance.signal(); else @@ -35,27 +31,21 @@ return object; } - public String getStartTransitionName() - { + public String getStartTransitionName() { return startTransitionName; } - public void setStartTransitionName(String startTransitionName) - { + public void setStartTransitionName(String startTransitionName) { this.startTransitionName = startTransitionName; } - @Override - public String getAdditionalToStringInformation() - { - return super.getAdditionalToStringInformation() - + ";startTransitionName=" + startTransitionName; - } - + public String getAdditionalToStringInformation() { + return super.getAdditionalToStringInformation() + ";startTransitionName=" + startTransitionName; + } + // methods for fluent programming - public StartProcessInstanceCommand startTransitionName(String startTransitionName) - { + public StartProcessInstanceCommand startTransitionName(String startTransitionName) { setStartTransitionName(startTransitionName); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartWorkOnTaskCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartWorkOnTaskCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/StartWorkOnTaskCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -2,16 +2,17 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.taskmgmt.exe.TaskInstance; /** - * The current authorizes actor starts to work on the TaskInstance so the actor is set to the given actor + * The current authorizes actor starts to work on the TaskInstance so the actor is set to the given + * actor * * @author Bernd Ruecker */ -public class StartWorkOnTaskCommand extends AbstractBaseCommand -{ +public class StartWorkOnTaskCommand extends AbstractBaseCommand { private static final long serialVersionUID = 53004484398726736L; @@ -23,23 +24,19 @@ private String actorId; - public StartWorkOnTaskCommand(long taskInstanceId, boolean overwriteSwimlane) - { + public StartWorkOnTaskCommand(long taskInstanceId, boolean overwriteSwimlane) { this.taskInstanceId = taskInstanceId; this.overwriteSwimlane = overwriteSwimlane; } - public StartWorkOnTaskCommand() - { + public StartWorkOnTaskCommand() { } - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { String actor = this.actorId == null ? jbpmContext.getActorId() : this.actorId; TaskInstance taskInstance = jbpmContext.getTaskInstance(taskInstanceId); - if (taskInstance.getStart() != null) - { + if (taskInstance.getStart() != null) { log.warn("Force stop on task " + taskInstance.getId() + ". Will be restarted."); taskInstance.setStart(null); // strange, but means isNotStarted() } @@ -49,60 +46,52 @@ return null; } - public boolean isOverwriteSwimlane() - { + public boolean isOverwriteSwimlane() { return overwriteSwimlane; } - public void setOverwriteSwimlane(boolean overwriteSwimlane) - { + public void setOverwriteSwimlane(boolean overwriteSwimlane) { this.overwriteSwimlane = overwriteSwimlane; } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public void setActorId(String actorId) - { + public void setActorId(String actorId) { this.actorId = actorId; } - public String getActorId() - { + public String getActorId() { return actorId; } - - @Override - public String getAdditionalToStringInformation() - { - return "tokenId=" + taskInstanceId - + ";transitionName=" + actorId - + ";processDefinitionName=" + overwriteSwimlane; + + public String getAdditionalToStringInformation() { + return "tokenId=" + + taskInstanceId + + ";transitionName=" + + actorId + + ";processDefinitionName=" + + overwriteSwimlane; } - + // methods for fluent programming - public StartWorkOnTaskCommand overwriteSwimlane(boolean overwriteSwimlane) - { + public StartWorkOnTaskCommand overwriteSwimlane(boolean overwriteSwimlane) { setOverwriteSwimlane(overwriteSwimlane); return this; } - public StartWorkOnTaskCommand taskInstanceId(long taskInstanceId) - { + public StartWorkOnTaskCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } - public StartWorkOnTaskCommand actorId(String actorId) - { + public StartWorkOnTaskCommand actorId(String actorId) { setActorId(actorId); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendProcessInstanceCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendProcessInstanceCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendProcessInstanceCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,20 +5,17 @@ /** * Suspend the specified {@link ProcessInstance}(s). See {@link AbstractProcessInstanceBaseCommand} - * to check possibilities to specify {@link ProcessInstance}(s). + * to check possibilities to specify {@link ProcessInstance}(s). With filter to all + * {@link ProcessDefinition}s this can be used like an emergency shutdown for + * {@link ProcessDefinition}s. * - * With filter to all {@link ProcessDefinition}s this can be used - * like an emergency shutdown for {@link ProcessDefinition}s. - * * @author bernd.ruecker(a)camunda.com */ public class SuspendProcessInstanceCommand extends AbstractProcessInstanceBaseCommand { private static final long serialVersionUID = 1L; - @Override - public ProcessInstance execute(ProcessInstance processInstance) - { + public ProcessInstance execute(ProcessInstance processInstance) { processInstance.suspend(); return processInstance; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendTokenCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendTokenCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/SuspendTokenCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -3,8 +3,8 @@ import org.jbpm.graph.exe.Token; /** - * Suspend the specified {@link Token}(s). See {@link AbstractTokenBaseCommand} - * to check possibilities to specify {@link Token}(s). + * Suspend the specified {@link Token}(s). See {@link AbstractTokenBaseCommand} to check + * possibilities to specify {@link Token}(s). * * @author bernd.ruecker(a)camunda.com */ @@ -12,9 +12,7 @@ private static final long serialVersionUID = 1L; - @Override - public Token execute(Token token) - { + public Object execute(Token token) { token.suspend(); return token; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/TaskInstanceEndCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/TaskInstanceEndCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/TaskInstanceEndCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -27,12 +27,12 @@ import org.jbpm.taskmgmt.exe.TaskInstance; /** - * end the task with the given id if variables are given as a map, they are added/changed bevore ending the task + * end the task with the given id if variables are given as a map, they are added/changed bevore + * ending the task * * @author ??, Bernd Ruecker (bernd.ruecker(a)camunda.com) */ -public class TaskInstanceEndCommand extends AbstractBaseCommand -{ +public class TaskInstanceEndCommand extends AbstractBaseCommand { private static final long serialVersionUID = 5721341060757950369L; @@ -44,106 +44,89 @@ private TaskInstance previoustaskInstance = null; - public TaskInstanceEndCommand() - { + public TaskInstanceEndCommand() { } - public TaskInstanceEndCommand(long taskInstanceId, String transitionName) - { + public TaskInstanceEndCommand(long taskInstanceId, String transitionName) { this.taskInstanceId = taskInstanceId; this.transitionName = transitionName; } - public TaskInstanceEndCommand(long taskInstanceId, String transitionName, Map variables) - { + public TaskInstanceEndCommand(long taskInstanceId, String transitionName, Map variables) { this.taskInstanceId = taskInstanceId; this.transitionName = transitionName; this.variables = variables; } - public Object execute(JbpmContext jbpmContext) - { + public Object execute(JbpmContext jbpmContext) { TaskInstance taskInstance = getTaskInstance(jbpmContext); - if (variables != null && variables.size() > 0) - { + if (variables != null && variables.size() > 0) { taskInstance.getContextInstance().addVariables(variables); } - if (transitionName == null) - { + if (transitionName == null) { taskInstance.end(); } - else - { + else { taskInstance.end(transitionName); } return taskInstance; } - protected TaskInstance getTaskInstance(JbpmContext jbpmContext) - { - if (previoustaskInstance != null) - { + protected TaskInstance getTaskInstance(JbpmContext jbpmContext) { + if (previoustaskInstance != null) { return previoustaskInstance; } return jbpmContext.getTaskInstance(taskInstanceId); } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public String getTransitionName() - { + public String getTransitionName() { return transitionName; } - public void setTransitionName(String transitionName) - { + public void setTransitionName(String transitionName) { this.transitionName = transitionName; } - public Map getVariables() - { + public Map getVariables() { return variables; } - public void setVariables(Map variables) - { + public void setVariables(Map variables) { this.variables = variables; } - @Override - public String getAdditionalToStringInformation() - { - return "taskInstanceId=" + taskInstanceId - + ";transitionName=" + transitionName - + ";variables=" + variables; - } + public String getAdditionalToStringInformation() { + return "taskInstanceId=" + + taskInstanceId + + ";transitionName=" + + transitionName + + ";variables=" + + variables; + } // methods for fluent programming - public TaskInstanceEndCommand taskInstanceId(long taskInstanceId) - { + public TaskInstanceEndCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } - public TaskInstanceEndCommand transitionName(String transitionName) - { + public TaskInstanceEndCommand transitionName(String transitionName) { setTransitionName(transitionName); return this; } - public TaskInstanceEndCommand variables(Map variables) - { + public TaskInstanceEndCommand variables(Map variables) { setVariables(variables); return this; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/VariablesCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/VariablesCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/VariablesCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -8,8 +8,7 @@ import org.jbpm.graph.exe.Token; import org.jbpm.taskmgmt.exe.TaskInstance; -public class VariablesCommand extends AbstractBaseCommand -{ +public class VariablesCommand extends AbstractBaseCommand { private static final long serialVersionUID = 1L; @@ -21,103 +20,81 @@ Token previousToken = null; TaskInstance previousTaskInstance = null; - public Object execute(JbpmContext jbpmContext) throws Exception - { + public Object execute(JbpmContext jbpmContext) throws Exception { VariableContainer variableContainer = getVariableContainer(jbpmContext); - if ((variableContainer != null) && (variables != null)) - { + if ((variableContainer != null) && (variables != null)) { variableContainer.addVariables(variables); } return variableContainer; } - protected VariableContainer getVariableContainer(JbpmContext jbpmContext) - { - if (previousProcessInstance != null) - { + protected VariableContainer getVariableContainer(JbpmContext jbpmContext) { + if (previousProcessInstance != null) { return getVariableContainer(previousProcessInstance.getRootToken()); } - if (previousToken != null) - { + if (previousToken != null) { return getVariableContainer(previousToken); } - if (previousTaskInstance != null) - { + if (previousTaskInstance != null) { return previousTaskInstance; } - if (tokenId != 0) - { + if (tokenId != 0) { return getVariableContainer(jbpmContext.getToken(tokenId)); } - if (taskInstanceId != 0) - { + if (taskInstanceId != 0) { return jbpmContext.getTaskInstance(taskInstanceId); } return null; } - protected VariableContainer getVariableContainer(Token token) - { + protected VariableContainer getVariableContainer(Token token) { return token.getProcessInstance().getContextInstance().getTokenVariableMap(token); } - public long getTaskInstanceId() - { + public long getTaskInstanceId() { return taskInstanceId; } - public void setTaskInstanceId(long taskInstanceId) - { + public void setTaskInstanceId(long taskInstanceId) { this.taskInstanceId = taskInstanceId; } - public long getTokenId() - { + public long getTokenId() { return tokenId; } - public void setTokenId(long tokenId) - { + public void setTokenId(long tokenId) { this.tokenId = tokenId; } - public Map getVariables() - { + public Map getVariables() { return variables; } - public void setVariables(Map variables) - { + public void setVariables(Map variables) { this.variables = variables; } - - @Override - public String getAdditionalToStringInformation() - { - return "tokenId=" + tokenId - + ";taskInstanceId=" + taskInstanceId - + ";variables=" + variables; - } + public String getAdditionalToStringInformation() { + return "tokenId=" + tokenId + ";taskInstanceId=" + taskInstanceId + ";variables=" + variables; + } + // methods for fluent programming - - public VariablesCommand taskInstanceId(long taskInstanceId) - { + + public VariablesCommand taskInstanceId(long taskInstanceId) { setTaskInstanceId(taskInstanceId); return this; } - public VariablesCommand tokenId(long tokenId) - { + public VariablesCommand tokenId(long tokenId) { setTokenId(tokenId); return this; } - public VariablesCommand variables(Map variables) - { + public VariablesCommand variables(Map variables) { setVariables(variables); return this; } - + } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/impl/CommandServiceImpl.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/impl/CommandServiceImpl.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/command/impl/CommandServiceImpl.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -37,47 +37,47 @@ * * @author Jim Rigsbee, Tom Baeyens */ -public class CommandServiceImpl implements CommandService, Serializable -{ +public class CommandServiceImpl implements CommandService, Serializable { + private static final long serialVersionUID = 1L; protected JbpmConfiguration jbpmConfiguration = null; /** - * Establish an instance of the command service with a particular jBPM configuration which provides connectivity to - * the jBPM engine and its related services including the persistence manager. + * Establish an instance of the command service with a particular jBPM configuration which + * provides connectivity to the jBPM engine and its related services including the persistence + * manager. * * @param jbpmConfiguration jBPM Configuration */ - public CommandServiceImpl(JbpmConfiguration jbpmConfiguration) - { + public CommandServiceImpl(JbpmConfiguration jbpmConfiguration) { this.jbpmConfiguration = jbpmConfiguration; } /** - * Executes command based on its current context. Each command contains the appropriate context information such as - * token, process instance, etc. to insure that the operation is carried out on the proper graph object. + * Executes command based on its current context. Each command contains the appropriate context + * information such as token, process instance, etc. to insure that the operation is carried out + * on the proper graph object. * * @param command jBPM engine command to execute */ - public Object execute(Command command) - { - Object result = null; + public Object execute(Command command) { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { log.debug("executing " + command); - result = command.execute(jbpmContext); + return command.execute(jbpmContext); } - catch (Exception e) - { - throw new JbpmException("couldn't execute " + command, e); + catch (RuntimeException e) { + jbpmContext.setRollbackOnly(); + throw e; } - finally - { + catch (Exception e) { + jbpmContext.setRollbackOnly(); + throw new JbpmException("failed to execute " + command, e); + } + finally { jbpmContext.close(); } - return result; } private static final Log log = LogFactory.getLog(CommandServiceImpl.class); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/configuration/ObjectFactoryImpl.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/configuration/ObjectFactoryImpl.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/configuration/ObjectFactoryImpl.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -37,7 +37,6 @@ private static final long serialVersionUID = 1L; - ClassLoader classLoader = null; // lazy load it later! See below.. List objectInfos = null; Map namedObjectInfos = null; Map singletons = new HashMap(); @@ -161,14 +160,7 @@ // "lazy load" classloader, shouldn't be loaded too early // because if jbpm.cfg.xml is not yet parsed, the correct class loader // may not be initialized yet. - if (classLoader==null) { - classLoader = ClassLoaderUtil.getClassLoader(); - } - try { - return classLoader.loadClass(className); - } catch (ClassNotFoundException e) { - throw new JbpmException("couldn't load class '"+className+"'", e); - } + return ClassLoaderUtil.loadClass(className); } Object getRegistryKey(ObjectInfo objectInfo) { Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/AbstractDbTestCase.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/AbstractDbTestCase.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/AbstractDbTestCase.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -23,7 +23,9 @@ // $Id$ +import java.util.Iterator; import java.util.Map; +import java.util.Map.Entry; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -31,6 +33,7 @@ import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; import org.hibernate.tool.hbm2ddl.SchemaExport; + import org.jbpm.AbstractJbpmTestCase; import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; @@ -75,15 +78,17 @@ private void ensureCleanDatabase() { boolean hasLeftOvers = false; - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) getJbpmConfiguration().getServiceFactory("persistence"); + DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) getJbpmConfiguration().getServiceFactory( + "persistence"); Configuration configuration = dbPersistenceServiceFactory.getConfiguration(); JbpmSchema jbpmSchema = new JbpmSchema(configuration); - Map<String, Long> rowsPerTable = jbpmSchema.getRowsPerTable(); - for (Map.Entry<String, Long> entry : rowsPerTable.entrySet()) { + Map rowsPerTable = jbpmSchema.getRowsPerTable(); + for (Iterator i = rowsPerTable.entrySet().iterator(); i.hasNext();) { + Map.Entry entry = (Entry) i.next(); // String tableName = entry.getKey(); - Long count = entry.getValue(); - if (count != 0) { + Long count = (Long) entry.getValue(); + if (count.intValue() != 0) { hasLeftOvers = true; // [JBPM-1812] Fix tests that don't cleanup the database // Only uncomment this if you intend to fix it. Otherwise it just generates noise. Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/GraphSession.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/GraphSession.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/GraphSession.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -24,6 +24,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; @@ -32,14 +33,13 @@ import org.hibernate.LockMode; import org.hibernate.Session; import org.hibernate.criterion.Restrictions; + import org.jbpm.JbpmException; -import org.jbpm.graph.def.Node; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.exe.Token; import org.jbpm.graph.node.ProcessState; -import org.jbpm.logging.log.ProcessLog; -import org.jbpm.util.CollectionUtil; +import org.jbpm.persistence.JbpmPersistenceException; /** * are the graph related database operations. @@ -49,6 +49,7 @@ final Session session; final JbpmSession jbpmSession; + /** @deprecated use {@link #GraphSession(Session)} instead */ public GraphSession(JbpmSession jbpmSession) { this.session = jbpmSession.getSession(); this.jbpmSession = jbpmSession; @@ -92,25 +93,25 @@ try { session.save(processDefinition); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not save " + processDefinition, e); + throw new JbpmPersistenceException("could not save " + processDefinition, e); } } /** * loads a process definition from the database by the identifier. * - * @throws JbpmException in case the referenced process definition doesn't exist. + * @throws JbpmPersistenceException in case the referenced process definition doesn't exist. */ public ProcessDefinition loadProcessDefinition(long processDefinitionId) { try { - return (ProcessDefinition) session.load(ProcessDefinition.class, - new Long(processDefinitionId)); + return (ProcessDefinition) session.load(ProcessDefinition.class, new Long(processDefinitionId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not load process definition " + processDefinitionId, e); + throw new JbpmPersistenceException( + "could not load process definition " + processDefinitionId, e); } } @@ -123,9 +124,10 @@ try { return (ProcessDefinition) session.get(ProcessDefinition.class, new Long(processDefinitionId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not get process definition " + processDefinitionId, e); + throw new JbpmPersistenceException("could not get process definition " + processDefinitionId, + e); } } @@ -139,9 +141,9 @@ .setInteger("version", version) .uniqueResult(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find process definition '" + throw new JbpmPersistenceException("could not find process definition '" + name + "' at version " + version, e); @@ -158,9 +160,9 @@ .setMaxResults(1) .uniqueResult(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find process definition '" + name + "'", e); + throw new JbpmPersistenceException("could not find process definition '" + name + "'", e); } } @@ -168,44 +170,41 @@ * queries the database for the latest version of each process definition. Process definitions are * distinct by name. */ - public List<ProcessDefinition> findLatestProcessDefinitions() { + public List findLatestProcessDefinitions() { try { - List<?> tuples = session.getNamedQuery("GraphSession.findLatestProcessDefinitions") - .list(); - List<ProcessDefinition> result = new ArrayList<ProcessDefinition>(); - for (Object[] tuple : CollectionUtil.checkList(tuples, Object[].class)) { + List tuples = session.getNamedQuery("GraphSession.findLatestProcessDefinitions").list(); + List result = new ArrayList(); + for (Iterator i = tuples.iterator(); i.hasNext();) { + Object[] tuple = (Object[]) i.next(); String name = (String) tuple[0]; Integer version = (Integer) tuple[1]; - result.add(findProcessDefinition(name, version)); + result.add(findProcessDefinition(name, version.intValue())); } return result; } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find latest versions of process definitions", e); + throw new JbpmPersistenceException("could not find latest versions of process definitions", e); } } - public List<ProcessDefinition> findProcessDefinitions(Collection<Long> processDefinitionIds) { - List<?> processDefinitions = session.createCriteria(ProcessDefinition.class) + public List findProcessDefinitions(Collection processDefinitionIds) { + return session.createCriteria(ProcessDefinition.class) .add(Restrictions.in("id", processDefinitionIds)) .list(); - return CollectionUtil.checkList(processDefinitions, ProcessDefinition.class); } /** * queries the database for all process definitions, ordered by name (ascending), then by version * (descending). */ - public List<ProcessDefinition> findAllProcessDefinitions() { + public List findAllProcessDefinitions() { try { - List<?> processDefinitions = session.getNamedQuery("GraphSession.findAllProcessDefinitions") - .list(); - return CollectionUtil.checkList(processDefinitions, ProcessDefinition.class); + return session.getNamedQuery("GraphSession.findAllProcessDefinitions").list(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find all process definitions", e); + throw new JbpmPersistenceException("could not find all process definitions", e); } } @@ -213,16 +212,17 @@ * queries the database for all versions of process definitions with the given name, ordered by * version (descending). */ - public List<ProcessDefinition> findAllProcessDefinitionVersions(String name) { + public List findAllProcessDefinitionVersions(String name) { try { - List<?> processDefinitions = session.getNamedQuery("GraphSession.findAllProcessDefinitionVersions") + return session.getNamedQuery("GraphSession.findAllProcessDefinitionVersions") .setString("name", name) .list(); - return CollectionUtil.checkList(processDefinitions, ProcessDefinition.class); } catch (HibernateException e) { log.error(e); - throw new JbpmException("could not find all versions of process definition '" + name + "'", e); + throw new JbpmPersistenceException("could not find all versions of process definition '" + + name + + "'", e); } } @@ -231,17 +231,14 @@ } public void deleteProcessDefinition(ProcessDefinition processDefinition) { - if (processDefinition == null) { - throw new IllegalArgumentException("processDefinition cannot be null"); - } - try { // delete all the process instances of this definition - List<?> processInstanceIds = session.getNamedQuery("GraphSession.findAllProcessInstanceIdsForDefinition") + List processInstanceIds = session.getNamedQuery("GraphSession.findAllProcessInstanceIdsForDefinition") .setLong("processDefinitionId", processDefinition.getId()) .list(); - for (Long processInstanceId : CollectionUtil.checkList(processInstanceIds, Long.class)) { - ProcessInstance processInstance = getProcessInstance(processInstanceId); + for (Iterator i = processInstanceIds.iterator(); i.hasNext();) { + Long processInstanceId = (Long) i.next(); + ProcessInstance processInstance = getProcessInstance(processInstanceId.longValue()); if (processInstance != null) { deleteProcessInstance(processInstance); } @@ -250,25 +247,25 @@ } } - List<ProcessState> referencingProcessStates = findReferencingProcessStates(processDefinition); - for (ProcessState processState : referencingProcessStates) { + List referencingProcessStates = findReferencingProcessStates(processDefinition); + for (Iterator i = referencingProcessStates.iterator(); i.hasNext();) { + ProcessState processState = (ProcessState) i.next(); processState.setSubProcessDefinition(null); } // then delete the process definition session.delete(processDefinition); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not delete " + processDefinition, e); + throw new JbpmPersistenceException("could not delete " + processDefinition, e); } } - List<ProcessState> findReferencingProcessStates(ProcessDefinition subProcessDefinition) { - List<?> processStates = session.getNamedQuery("GraphSession.findReferencingProcessStates") + List findReferencingProcessStates(ProcessDefinition subProcessDefinition) { + return session.getNamedQuery("GraphSession.findReferencingProcessStates") .setEntity("subProcessDefinition", subProcessDefinition) .list(); - return CollectionUtil.checkList(processStates, ProcessState.class); } // process instances //////////////////////////////////////////////////////// @@ -286,15 +283,15 @@ * the process instance doesn't exist. * * @see #getProcessInstance(long) - * @throws JbpmException in case the process instance doesn't exist. + * @throws JbpmPersistenceException in case the process instance doesn't exist. */ public ProcessInstance loadProcessInstance(long processInstanceId) { try { return (ProcessInstance) session.load(ProcessInstance.class, new Long(processInstanceId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not load process instance " + processInstanceId, e); + throw new JbpmPersistenceException("could not load process instance " + processInstanceId, e); } } @@ -306,9 +303,9 @@ try { return (ProcessInstance) session.get(ProcessInstance.class, new Long(processInstanceId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not get process instance " + processInstanceId, e); + throw new JbpmPersistenceException("could not get process instance " + processInstanceId, e); } } @@ -316,15 +313,15 @@ * loads a token from the database by the identifier. * * @return the token. - * @throws JbpmException in case the referenced token doesn't exist. + * @throws JbpmPersistenceException in case the referenced token doesn't exist. */ public Token loadToken(long tokenId) { try { return (Token) session.load(Token.class, new Long(tokenId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not load token " + tokenId, e); + throw new JbpmPersistenceException("could not load token " + tokenId, e); } } @@ -337,9 +334,9 @@ try { return (Token) session.get(Token.class, new Long(tokenId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not get token " + tokenId, e); + throw new JbpmPersistenceException("could not get token " + tokenId, e); } } @@ -348,11 +345,11 @@ */ public void lockProcessInstance(long processInstanceId) { try { - session.load(ProcessInstance.class, processInstanceId, LockMode.UPGRADE); + session.load(ProcessInstance.class, new Long(processInstanceId), LockMode.UPGRADE); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not lock process instance " + processInstanceId, e); + throw new JbpmPersistenceException("could not lock process instance " + processInstanceId, e); } } @@ -363,9 +360,9 @@ try { session.lock(processInstance, LockMode.UPGRADE); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not lock " + processInstance, e); + throw new JbpmPersistenceException("could not lock " + processInstance, e); } } @@ -373,16 +370,15 @@ * fetches all processInstances for the given process definition from the database. The returned * list of process instances is sorted start date, youngest first. */ - public List<ProcessInstance> findProcessInstances(long processDefinitionId) { + public List findProcessInstances(long processDefinitionId) { try { - List<?> processInstances = session.getNamedQuery("GraphSession.findAllProcessInstancesForDefinition") + return session.getNamedQuery("GraphSession.findAllProcessInstancesForDefinition") .setLong("processDefinitionId", processDefinitionId) .list(); - return CollectionUtil.checkList(processInstances, ProcessInstance.class); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find process instances for process definition " + throw new JbpmPersistenceException("could not find process instances for process definition " + processDefinitionId, e); } } @@ -433,11 +429,11 @@ // delete tasks (TaskLogs reference tasks, so tasks must be deleted after logs) if (includeTasks) { log.debug("deleting tasks for " + processInstance); - List<?> tasks = session.getNamedQuery("GraphSession.findTaskInstancesForProcessInstance") + List tasks = session.getNamedQuery("GraphSession.findTaskInstancesForProcessInstance") .setEntity("processInstance", processInstance) .list(); - for (Object task : tasks) { - session.delete(task); + for (Iterator i = tasks.iterator(); i.hasNext();) { + session.delete(i.next()); } } @@ -445,24 +441,24 @@ log.debug("deleting " + processInstance); session.delete(processInstance); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not delete " + processInstance, e); + throw new JbpmPersistenceException("could not delete " + processInstance, e); } } void deleteLogs(ProcessInstance processInstance) { - List<?> logs = session.getNamedQuery("GraphSession.findLogsForProcessInstance") + List logs = session.getNamedQuery("GraphSession.findLogsForProcessInstance") .setEntity("processInstance", processInstance) .list(); - for (ProcessLog processLog : CollectionUtil.checkList(logs, ProcessLog.class)) { - session.delete(processLog); + for (Iterator i = logs.iterator(); i.hasNext();) { + session.delete(i.next()); } } void deleteSubProcesses(ProcessInstance processInstance) { if (processInstance != null) { - List<?> subProcessInstances = session.getNamedQuery("GraphSession.findSubProcessInstances") + List subProcessInstances = session.getNamedQuery("GraphSession.findSubProcessInstances") .setEntity("processInstance", processInstance) .list(); @@ -471,7 +467,8 @@ return; } - for (ProcessInstance subProcessInstance : CollectionUtil.checkList(subProcessInstances, ProcessInstance.class)) { + for (Iterator i = subProcessInstances.iterator(); i.hasNext();) { + ProcessInstance subProcessInstance = (ProcessInstance) i.next(); log.debug("preparing to delete sub process instance " + subProcessInstance.getId()); deleteProcessInstance(subProcessInstance); } @@ -536,19 +533,19 @@ } } - public List<AverageNodeTimeEntry> calculateAverageTimeByNode(long processDefinitionId, - long minumumDurationMillis) { + public List calculateAverageTimeByNode(long processDefinitionId, long minumumDurationMillis) { try { - List<?> tuples = session.getNamedQuery("GraphSession.calculateAverageTimeByNode") + List tuples = session.getNamedQuery("GraphSession.calculateAverageTimeByNode") .setLong("processDefinitionId", processDefinitionId) .setDouble("minimumDuration", minumumDurationMillis) .list(); - List<AverageNodeTimeEntry> results; + List results; if (!tuples.isEmpty()) { - results = new ArrayList<AverageNodeTimeEntry>(); + results = new ArrayList(); - for (Object[] values : CollectionUtil.checkList(tuples, Object[].class)) { + for (Iterator i = tuples.iterator(); i.hasNext();) { + Object[] values = (Object[]) i.next(); AverageNodeTimeEntry averageNodeTimeEntry = new AverageNodeTimeEntry(); averageNodeTimeEntry.setNodeId(((Number) values[0]).longValue()); averageNodeTimeEntry.setNodeName((String) values[1]); @@ -561,27 +558,27 @@ } } else { - results = Collections.emptyList(); + results = Collections.EMPTY_LIST; } return results; } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not calculate average time by node for process definition " - + processDefinitionId, e); + throw new JbpmPersistenceException( + "could not calculate average time by node for process definition " + processDefinitionId, + e); } } - public List<Node> findActiveNodesByProcessInstance(ProcessInstance processInstance) { + public List findActiveNodesByProcessInstance(ProcessInstance processInstance) { try { - List<?> nodes = session.getNamedQuery("GraphSession.findActiveNodesByProcessInstance") + return session.getNamedQuery("GraphSession.findActiveNodesByProcessInstance") .setEntity("processInstance", processInstance) .list(); - return CollectionUtil.checkList(nodes, Node.class); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not find active nodes for " + processInstance, e); + throw new JbpmPersistenceException("could not find active nodes for " + processInstance, e); } } @@ -592,9 +589,9 @@ .setString("key", key) .uniqueResult(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("could not get process instance with key '" + key + "'", e); + throw new JbpmPersistenceException("could not get process instance with key '" + key + "'", e); } } @@ -606,8 +603,9 @@ return processInstance; } - private void handle(Exception e) { - log.error(e); + private void handle(HibernateException exception) { + // exception will be rethrown, no need to log here at a verbose level + log.debug(exception); if (jbpmSession != null) jbpmSession.handleException(); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JbpmSchema.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JbpmSchema.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JbpmSchema.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -50,6 +50,7 @@ import org.hibernate.tool.hbm2ddl.DatabaseMetadata; import org.hibernate.tool.hbm2ddl.TableMetadata; import org.hibernate.util.JDBCExceptionReporter; + import org.jbpm.JbpmException; /** @@ -63,7 +64,7 @@ ConnectionProvider connectionProvider = null; Connection connection = null; - final List<SQLException> exceptions = new ArrayList<SQLException>(); + final List exceptions = new ArrayList(); public JbpmSchema(Configuration configuration) { this.configuration = configuration; @@ -82,9 +83,9 @@ return concat(getDropSql(), getCreateSql()); } - public Set<String> getJbpmTables() { - Set<String> jbpmTables = new HashSet<String>(); - for (Iterator<?> i = configuration.getTableMappings(); i.hasNext();) { + public Set getJbpmTables() { + Set jbpmTables = new HashSet(); + for (Iterator i = configuration.getTableMappings(); i.hasNext();) { Table table = (Table) i.next(); if (table.isPhysicalTable()) { jbpmTables.add(table.getName()); @@ -93,10 +94,10 @@ return jbpmTables; } - public Set<String> getExistingTables() { + public Set getExistingTables() { try { createConnection(); - Set<String> existingTables = new HashSet<String>(); + Set existingTables = new HashSet(); DatabaseMetaData metaData = connection.getMetaData(); boolean storesLowerCaseIdentifiers = metaData.storesLowerCaseIdentifiers(); @@ -124,12 +125,13 @@ } } - public Map<String, Long> getRowsPerTable() { - Map<String, Long> rowsPerTable = new HashMap<String, Long>(); + public Map getRowsPerTable() { + Map rowsPerTable = new HashMap(); try { createConnection(); Statement statement = connection.createStatement(); - for (String tableName : getJbpmTables()) { + for (Iterator i = getJbpmTables().iterator(); i.hasNext();) { + String tableName = (String) i.next(); String sql = "SELECT COUNT(*) FROM " + tableName; ResultSet resultSet = statement.executeQuery(sql); if (!resultSet.next()) throw new JbpmException("empty result set: " + sql); @@ -137,7 +139,7 @@ long count = resultSet.getLong(1); if (resultSet.wasNull()) throw new JbpmException("count was null: " + sql); - rowsPerTable.put(tableName, count); + rowsPerTable.put(tableName, new Long(count)); resultSet.close(); } statement.close(); @@ -219,7 +221,7 @@ String sql = table.sqlCreateString(settings.getDialect(), configuration.buildMapping(), settings.getDefaultCatalogName(), settings.getDefaultSchemaName()); try { - execute(sql); + execute(new String[] { sql }); } catch (SQLException e) { throw new JbpmException("could not create table: " + tableName, e); @@ -230,7 +232,7 @@ Table table = findTableMapping(tableName); try { createConnection(); - Iterator<?> sqls = table.sqlAlterStrings(settings.getDialect(), configuration.buildMapping(), + Iterator sqls = table.sqlAlterStrings(settings.getDialect(), configuration.buildMapping(), getTableMetadata(table), settings.getDefaultCatalogName(), settings.getDefaultSchemaName()); @@ -249,12 +251,12 @@ } } - public List<SQLException> getExceptions() { + public List getExceptions() { return exceptions; } private Table findTableMapping(String tableName) { - for (Iterator<?> i = configuration.getTableMappings(); i.hasNext();) { + for (Iterator i = configuration.getTableMappings(); i.hasNext();) { Table table = (Table) i.next(); if (tableName.equals(table.getName())) { return table; @@ -328,8 +330,8 @@ void saveSqlScript(String fileName, String[] sql) throws IOException { PrintStream out = new PrintStream(new FileOutputStream(fileName)); try { - for (String line : sql) { - out.println(line + getSqlDelimiter()); + for (int i = 0; i < sql.length; i++) { + out.println(sql[i] + getSqlDelimiter()); } } finally { @@ -337,17 +339,18 @@ } } - void execute(String... sqls) throws SQLException { + void execute(String[] sql) throws SQLException { boolean showSql = settings.isShowSqlEnabled(); exceptions.clear(); try { createConnection(); Statement statement = connection.createStatement(); - for (String sql : sqls) { - if (showSql) System.out.println(sql); - log.debug(sql); + for (int i = 0; i < sql.length; i++) { + String line = sql[i]; + if (showSql) System.out.println(line); + log.debug(line); try { - statement.executeUpdate(sql); + statement.executeUpdate(line); } catch (SQLException e) { exceptions.add(e); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JobSession.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JobSession.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/JobSession.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,9 +21,9 @@ */ package org.jbpm.db; -import java.util.Arrays; import java.util.Collection; import java.util.Date; +import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; @@ -32,12 +32,13 @@ import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.criterion.Restrictions; -import org.jbpm.JbpmException; + import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.exe.Token; import org.jbpm.job.Job; import org.jbpm.job.Timer; -import org.jbpm.util.CollectionUtil; +import org.jbpm.persistence.JbpmPersistenceException; +import org.jbpm.util.ArrayUtil; public class JobSession { @@ -56,40 +57,38 @@ .uniqueResult(); } catch (HibernateException e) { - throw new JbpmException("could not get first acquirable job", e); + throw new JbpmPersistenceException("could not get first acquirable job", e); } } - public List<Job> findExclusiveJobs(String lockOwner, ProcessInstance processInstance) { + public List findExclusiveJobs(String lockOwner, ProcessInstance processInstance) { try { - List<?> jobs = session.getNamedQuery("JobSession.findExclusiveJobs") + return session.getNamedQuery("JobSession.findExclusiveJobs") .setString("lockOwner", lockOwner) .setTimestamp("now", new Date()) .setParameter("processInstance", processInstance) .list(); - return CollectionUtil.checkList(jobs, Job.class); } catch (HibernateException e) { - throw new JbpmException("could not find exclusive jobs owned by '" + throw new JbpmPersistenceException("could not find exclusive jobs owned by '" + lockOwner + "' for " + processInstance, e); } } - public List<Job> findJobsByToken(Token token) { + public List findJobsByToken(Token token) { try { - List<?> jobs = session.getNamedQuery("JobSession.findJobsByToken") + return session.getNamedQuery("JobSession.findJobsByToken") .setParameter("token", token) .list(); - return CollectionUtil.checkList(jobs, Job.class); } catch (HibernateException e) { - throw new JbpmException("could not find jobs for " + token, e); + throw new JbpmPersistenceException("could not find jobs for " + token, e); } } - public Job getFirstDueJob(String lockOwner, Collection<Long> monitoredJobs) { + public Job getFirstDueJob(String lockOwner, Collection monitoredJobs) { try { Query query; if (monitoredJobs == null || monitoredJobs.isEmpty()) { @@ -99,12 +98,10 @@ query = session.getNamedQuery("JobSession.getFirstDueJobExcludingMonitoredJobs"); query.setParameterList("monitoredJobIds", monitoredJobs); } - return (Job) query.setString("lockOwner", lockOwner) - .setMaxResults(1) - .uniqueResult(); + return (Job) query.setString("lockOwner", lockOwner).setMaxResults(1).uniqueResult(); } catch (HibernateException e) { - throw new JbpmException("could not get first due job owned by '" + throw new JbpmPersistenceException("could not get first due job owned by '" + lockOwner + "' ignoring jobs " + monitoredJobs, e); @@ -116,7 +113,7 @@ session.save(job); } catch (HibernateException e) { - throw new JbpmException("could not save " + job, e); + throw new JbpmPersistenceException("could not save " + job, e); } } @@ -126,7 +123,7 @@ log.debug("deleted " + job); } catch (HibernateException e) { - throw new JbpmException("could not delete " + job, e); + throw new JbpmPersistenceException("could not delete " + job, e); } } @@ -135,7 +132,7 @@ return (Job) session.load(Job.class, new Long(jobId)); } catch (HibernateException e) { - throw new JbpmException("could not load job " + jobId, e); + throw new JbpmPersistenceException("could not load job " + jobId, e); } } @@ -144,19 +141,18 @@ return (Timer) session.load(Timer.class, new Long(timerId)); } catch (HibernateException e) { - throw new JbpmException("could not load timer " + timerId, e); + throw new JbpmPersistenceException("could not load timer " + timerId, e); } } - public List<Job> loadJobs(long... jobIds) { + public List loadJobs(long[] jobIds) { try { - List<?> jobs = session.createCriteria(Job.class) + return session.createCriteria(Job.class) .add(Restrictions.in("id", toObjectArray(jobIds))) .list(); - return CollectionUtil.checkList(jobs, Job.class); } catch (HibernateException e) { - throw new JbpmException("could not load jobs " + Arrays.toString(jobIds), e); + throw new JbpmPersistenceException("could not load jobs " + ArrayUtil.toString(jobIds), e); } } @@ -164,7 +160,7 @@ final int length = primitives.length; Long[] objects = new Long[length]; for (int i = 0; i < length; i++) { - objects[i] = primitives[i]; + objects[i] = new Long(primitives[i]); } return objects; } @@ -174,7 +170,7 @@ return (Job) session.get(Job.class, new Long(jobId)); } catch (HibernateException e) { - throw new JbpmException("could not get job " + jobId, e); + throw new JbpmPersistenceException("could not get job " + jobId, e); } } @@ -183,7 +179,7 @@ session.getNamedQuery("JobSession.suspendJobs").setParameter("token", token).executeUpdate(); } catch (HibernateException e) { - throw new JbpmException("could not suspend jobs for " + token, e); + throw new JbpmPersistenceException("could not suspend jobs for " + token, e); } } @@ -192,7 +188,7 @@ session.getNamedQuery("JobSession.resumeJobs").setParameter("token", token).executeUpdate(); } catch (HibernateException e) { - throw new JbpmException("could not resume jobs for " + token, e); + throw new JbpmPersistenceException("could not resume jobs for " + token, e); } } @@ -206,14 +202,17 @@ log.debug("deleted " + entityCount + " timers by name '" + name + "' for " + token); // prevent further repetitions - List<?> timers = session.getNamedQuery("JobSession.findRepeatingTimersByName") + List timers = session.getNamedQuery("JobSession.findRepeatingTimersByName") .setString("name", name) .setParameter("token", token) .list(); preventFurtherRepetitions(timers); } catch (HibernateException e) { - throw new JbpmException("could not delete timers by name '" + name + "' for " + token, e); + throw new JbpmPersistenceException("could not delete timers by name '" + + name + + "' for " + + token, e); } } @@ -233,34 +232,34 @@ log.debug("deleted " + entityCount + " jobs for " + processInstance); // prevent further repetitions - List<?> timers = session.getNamedQuery("JobSession.findRepeatingTimersForProcessInstance") + List timers = session.getNamedQuery("JobSession.findRepeatingTimersForProcessInstance") .setParameter("processInstance", processInstance) .list(); preventFurtherRepetitions(timers); } catch (HibernateException e) { - throw new JbpmException("could not delete jobs for " + processInstance, e); + throw new JbpmPersistenceException("could not delete jobs for " + processInstance, e); } } - private static void preventFurtherRepetitions(List<?> timers) { + private static void preventFurtherRepetitions(List timers) { if (!timers.isEmpty()) { - for (Timer timer : CollectionUtil.checkList(timers, Timer.class)) { + for (Iterator i = timers.iterator(); i.hasNext();) { + Timer timer = (Timer) i.next(); timer.setRepeat(null); } log.debug("prevented further repetitions of " + timers); } } - public List<Job> findJobsWithOverdueLockTime(Date threshold) { + public List findJobsWithOverdueLockTime(Date threshold) { try { - List<?> jobs = session.getNamedQuery("JobSession.findJobsWithOverdueLockTime") + return session.getNamedQuery("JobSession.findJobsWithOverdueLockTime") .setDate("threshold", threshold) .list(); - return CollectionUtil.checkList(jobs, Job.class); } catch (HibernateException e) { - throw new JbpmException("could not find jobs with lock time over " + threshold, e); + throw new JbpmPersistenceException("could not find jobs with lock time over " + threshold, e); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/LoggingSession.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/LoggingSession.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/LoggingSession.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -28,90 +28,88 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.hibernate.Query; +import org.hibernate.HibernateException; import org.hibernate.Session; -import org.jbpm.JbpmException; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.exe.Token; import org.jbpm.logging.log.ProcessLog; +import org.jbpm.persistence.JbpmPersistenceException; public class LoggingSession { - JbpmSession jbpmSession; - Session session; - + final JbpmSession jbpmSession; + final Session session; + + /** @deprecated use {@link #LoggingSession(Session)} instead */ public LoggingSession(JbpmSession jbpmSession) { + this.session = jbpmSession.getSession(); this.jbpmSession = jbpmSession; - this.session = jbpmSession.getSession(); } - + public LoggingSession(Session session) { this.session = session; - this.jbpmSession = new JbpmSession(session); + this.jbpmSession = null; } /** - * returns a map that maps {@link Token}s to {@link List}s. The lists contain the ordered - * logs for the given token. The lists are retrieved with {@link #findLogsByToken(long)}. + * returns a map that maps {@link Token}s to {@link List}s. The lists contain the ordered logs for + * the given token. The lists are retrieved with {@link #findLogsByToken(long)}. */ public Map findLogsByProcessInstance(long processInstanceId) { Map tokenLogs = new HashMap(); try { - ProcessInstance processInstance = (ProcessInstance) session.load(ProcessInstance.class, new Long(processInstanceId)); + ProcessInstance processInstance = (ProcessInstance) session.load(ProcessInstance.class, new Long( + processInstanceId)); collectTokenLogs(tokenLogs, processInstance.getRootToken()); - } catch (Exception e) { - log.error(e); - jbpmSession.handleException(); - throw new JbpmException("couldn't get logs for process instance '"+processInstanceId+"'", e); - } + } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't get logs for process instance " + + processInstanceId, e); + } return tokenLogs; } private void collectTokenLogs(Map tokenLogs, Token token) { tokenLogs.put(token, findLogsByToken(token.getId())); Map children = token.getChildren(); - if ( (children!=null) - && (!children.isEmpty()) - ) { - Iterator iter = children.values().iterator(); - while (iter.hasNext()) { - Token child = (Token) iter.next(); + if (children != null) { + for (Iterator i = children.values().iterator(); i.hasNext();) { + Token child = (Token) i.next(); collectTokenLogs(tokenLogs, child); } } } - + /** * collects the logs for a given token, ordered by creation time. */ public List findLogsByToken(long tokenId) { - List result = null; try { Token token = (Token) session.load(Token.class, new Long(tokenId)); - Query query = session.getNamedQuery("LoggingSession.findLogsByToken"); - query.setEntity("token", token); - result = query.list(); - } catch (Exception e) { - log.error(e); - jbpmSession.handleException(); - throw new JbpmException("couldn't get logs for token '"+tokenId+"'", e); - } - return result; + return session.getNamedQuery("LoggingSession.findLogsByToken") + .setEntity("token", token) + .list(); + } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't get logs for token '" + tokenId + "'", e); + } } - + /** * saves the given process log to the database. */ public void saveProcessLog(ProcessLog processLog) { try { session.save(processLog); - } catch (Exception e) { - log.error(e); - jbpmSession.handleException(); - throw new JbpmException("couldn't save process log '"+processLog+"'", e); - } + } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't save process log '" + processLog + "'", e); + } } - + /** * load the process log for a given id. */ @@ -119,14 +117,14 @@ ProcessLog processLog = null; try { processLog = (ProcessLog) session.load(ProcessLog.class, new Long(processLogId)); - } catch (Exception e) { - log.error(e); - jbpmSession.handleException(); - throw new JbpmException("couldn't load process log '"+processLogId+"'", e); - } + } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't load process log '" + processLogId + "'", e); + } return processLog; } - + /** * get the process log for a given id. */ @@ -134,13 +132,19 @@ ProcessLog processLog = null; try { processLog = (ProcessLog) session.get(ProcessLog.class, new Long(processLogId)); - } catch (Exception e) { - log.error(e); - jbpmSession.handleException(); - throw new JbpmException("couldn't get process log '"+processLogId+"'", e); - } + } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't get process log '" + processLogId + "'", e); + } return processLog; } - + + private void handle(HibernateException exception) { + // exception will be rethrown, no need to log here at a verbose level + log.debug(exception); + if (jbpmSession != null) jbpmSession.handleException(); + } + private static final Log log = LogFactory.getLog(LoggingSession.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/TaskMgmtSession.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/TaskMgmtSession.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/db/TaskMgmtSession.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,27 +21,24 @@ */ package org.jbpm.db; -import java.io.Serializable; import java.util.Arrays; -import java.util.Collections; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.hibernate.Query; +import org.hibernate.HibernateException; import org.hibernate.Session; -import org.jbpm.JbpmException; + import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.persistence.JbpmPersistenceException; import org.jbpm.taskmgmt.exe.TaskInstance; -import org.jbpm.util.CollectionUtil; -public class TaskMgmtSession implements Serializable { +public class TaskMgmtSession { - private static final long serialVersionUID = 1L; - final Session session; final JbpmSession jbpmSession; + /** @deprecated use {@link #TaskMgmtSession(Session)} instead */ public TaskMgmtSession(JbpmSession jbpmSession) { this.session = jbpmSession.getSession(); this.jbpmSession = jbpmSession; @@ -55,15 +52,17 @@ /** * get the tasklist for a given actor. */ - public List<TaskInstance> findTaskInstances(String actorId) { + public List findTaskInstances(String actorId) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByActorId"); - query.setString("actorId", actorId); - return CollectionUtil.checkList(query.list(), TaskInstance.class); + return session.getNamedQuery("TaskMgmtSession.findTaskInstancesByActorId") + .setString("actorId", actorId) + .list(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instances list for actor '" + actorId + "'", e); + throw new JbpmPersistenceException("couldn't get task instances list for actor '" + + actorId + + "'", e); } } @@ -71,57 +70,60 @@ * get all the task instances for all the given actorIds. * * @return a list of task instances. An empty list is returned in case no task instances are - * found. + * found. */ - public List<TaskInstance> findTaskInstances(List<String> actorIds) { + public List findTaskInstances(List actorIds) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByActorIds"); - query.setParameterList("actorIds", actorIds); - return CollectionUtil.checkList(query.list(), TaskInstance.class); + return session.getNamedQuery("TaskMgmtSession.findTaskInstancesByActorIds") + .setParameterList("actorIds", actorIds) + .list(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instances list for actors '" + actorIds + "'", e); + throw new JbpmPersistenceException("couldn't get task instances list for actors '" + + actorIds + + "'", e); } } /** * get all the task instances for all the given actorIds. */ - public List<TaskInstance> findTaskInstances(String[] actorIds) { + public List findTaskInstances(String[] actorIds) { return findTaskInstances(Arrays.asList(actorIds)); } /** * get the task instances for which the given actor is in the pool. */ - public List<TaskInstance> findPooledTaskInstances(String actorId) { + public List findPooledTaskInstances(String actorId) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findPooledTaskInstancesByActorId"); - query.setString("actorId", actorId); - List<Long> taskInstanceIds = CollectionUtil.checkList(query.list(), Long.class); + List taskInstanceIds = session.getNamedQuery("TaskMgmtSession.findPooledTaskInstancesByActorId") + .setString("actorId", actorId) + .list(); return findTaskInstancesByIds(taskInstanceIds); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException( - "couldn't get pooled task instances list for actor '" + actorId + "'", e); + throw new JbpmPersistenceException("couldn't get pooled task instances list for actor '" + + actorId + + "'", e); } } /** * get the task instances for which the given actor is in the pool. */ - public List<TaskInstance> findPooledTaskInstances(List<String> actorIds) { + public List findPooledTaskInstances(List actorIds) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findPooledTaskInstancesByActorIds"); - query.setParameterList("actorIds", actorIds); - List<Long> taskInstanceIds = CollectionUtil.checkList(query.list(), Long.class); + List taskInstanceIds = session.getNamedQuery("TaskMgmtSession.findPooledTaskInstancesByActorIds") + .setParameterList("actorIds", actorIds) + .list(); return findTaskInstancesByIds(taskInstanceIds); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get pooled task instances list for actors '" + throw new JbpmPersistenceException("couldn't get pooled task instances list for actors '" + actorIds + "'", e); } @@ -130,30 +132,31 @@ /** * get active task instances for a given token. */ - public List<TaskInstance> findTaskInstancesByToken(long tokenId) { + public List findTaskInstancesByToken(long tokenId) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByTokenId"); - query.setLong("tokenId", tokenId); - return CollectionUtil.checkList(query.list(), TaskInstance.class); + return session.getNamedQuery("TaskMgmtSession.findTaskInstancesByTokenId") + .setLong("tokenId", tokenId) + .list(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instances by token '" + tokenId + "'", e); + throw new JbpmPersistenceException("couldn't get task instances by token '" + tokenId + "'", + e); } } /** * get active task instances for a given process instance. */ - public List<TaskInstance> findTaskInstancesByProcessInstance(ProcessInstance processInstance) { + public List findTaskInstancesByProcessInstance(ProcessInstance processInstance) { try { - Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByProcessInstance"); - query.setEntity("processInstance", processInstance); - return CollectionUtil.checkList(query.list(), TaskInstance.class); + return session.getNamedQuery("TaskMgmtSession.findTaskInstancesByProcessInstance") + .setEntity("processInstance", processInstance) + .list(); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instances by process instance '" + throw new JbpmPersistenceException("couldn't get task instances by process instance '" + processInstance + "'", e); } @@ -167,9 +170,9 @@ try { taskInstance = (TaskInstance) session.load(TaskInstance.class, new Long(taskInstanceId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instance '" + taskInstanceId + "'", e); + throw new JbpmPersistenceException("couldn't get task instance '" + taskInstanceId + "'", e); } return taskInstance; } @@ -182,36 +185,31 @@ try { taskInstance = (TaskInstance) session.get(TaskInstance.class, new Long(taskInstanceId)); } - catch (Exception e) { + catch (HibernateException e) { handle(e); - throw new JbpmException("couldn't get task instance '" + taskInstanceId + "'", e); + throw new JbpmPersistenceException("couldn't get task instance '" + taskInstanceId + "'", e); } return taskInstance; } - public List<TaskInstance> findTaskInstancesByIds(List<Long> taskInstanceIds) { - List<TaskInstance> result; - if (taskInstanceIds.isEmpty()) { - result = Collections.emptyList(); + public List findTaskInstancesByIds(List taskInstanceIds) { + try { + return session.getNamedQuery("TaskMgmtSession.findTaskInstancesByIds") + .setParameterList("taskInstanceIds", taskInstanceIds) + .list(); } - else { - try { - Query query = session.getNamedQuery("TaskMgmtSession.findTaskInstancesByIds"); - query.setParameterList("taskInstanceIds", taskInstanceIds); - result = CollectionUtil.checkList(query.list(), TaskInstance.class); - } - catch (Exception e) { - handle(e); - throw new JbpmException("couldn't get task instances by ids '" + taskInstanceIds + "'", e); - } + catch (HibernateException e) { + handle(e); + throw new JbpmPersistenceException("couldn't get task instances by ids '" + + taskInstanceIds + + "'", e); } - return result; } - private void handle(Exception exception) { - log.error(exception); - if (jbpmSession != null) - jbpmSession.handleException(); + private void handle(HibernateException exception) { + // exception will be rethrown, no need to log here at a verbose level + log.debug(exception); + if (jbpmSession != null) jbpmSession.handleException(); } private static final Log log = LogFactory.getLog(TaskMgmtSession.class); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Action.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Action.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Action.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -25,26 +25,27 @@ import java.util.Map; import org.dom4j.Element; + import org.jbpm.JbpmConfiguration; import org.jbpm.graph.exe.ExecutionContext; import org.jbpm.instantiation.Delegation; import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator; import org.jbpm.jpdl.xml.JpdlXmlReader; import org.jbpm.jpdl.xml.Parsable; -import org.jbpm.util.ClassLoaderUtil; +import org.jbpm.util.ClassUtil; import org.jbpm.util.EqualsUtil; public class Action implements ActionHandler, Parsable, Serializable { private static final long serialVersionUID = 1L; - + long id = 0; protected String name = null; protected boolean isPropagationAllowed = true; protected boolean isAsync = false; protected boolean isAsyncExclusive = false; protected Action referencedAction = null; - protected Delegation actionDelegation = null; + protected Delegation actionDelegation = null; protected String actionExpression = null; protected Event event = null; protected ProcessDefinition processDefinition = null; @@ -55,41 +56,47 @@ public Action(Delegation actionDelegate) { this.actionDelegation = actionDelegate; } - + public String toString() { String toString = null; - if (actionExpression!=null) { - toString = "Action("+actionExpression+')'; - } else { - String className = getClass().getSimpleName(); - if (name!=null) { - toString = className+'('+name+')'; - } else { - toString = className+&#39;(a)&#39;+Integer.toHexString(hashCode()); + if (actionExpression != null) { + toString = "Action(" + actionExpression + ')'; + } + else { + String className = ClassUtil.getSimpleName(getClass()); + if (name != null) { + toString = className + '(' + name + ')'; } + else { + toString = className + '@' + Integer.toHexString(hashCode()); + } } return toString; } public void read(Element actionElement, JpdlXmlReader jpdlReader) { String expression = actionElement.attributeValue("expression"); - if (expression!=null) { + if (expression != null) { actionExpression = expression; - } else if (actionElement.attribute("ref-name")!=null) { + } + else if (actionElement.attribute("ref-name") != null) { jpdlReader.addUnresolvedActionReference(actionElement, this); - } else if (actionElement.attribute("class")!=null) { + } + else if (actionElement.attribute("class") != null) { actionDelegation = new Delegation(); actionDelegation.read(actionElement, jpdlReader); - - } else { - jpdlReader.addWarning("action does not have class nor ref-name attribute "+actionElement.asXML()); + } + else { + jpdlReader.addWarning("action does not have class nor ref-name attribute " + + actionElement.asXML()); + } String acceptPropagatedEvents = actionElement.attributeValue("accept-propagated-events"); if ("false".equalsIgnoreCase(acceptPropagatedEvents) - || "no".equalsIgnoreCase(acceptPropagatedEvents) + || "no".equalsIgnoreCase(acceptPropagatedEvents) || "off".equalsIgnoreCase(acceptPropagatedEvents)) { isPropagationAllowed = false; } @@ -97,14 +104,15 @@ String asyncText = actionElement.attributeValue("async"); if ("true".equalsIgnoreCase(asyncText)) { isAsync = true; - } else if ("exclusive".equalsIgnoreCase(asyncText)) { + } + else if ("exclusive".equalsIgnoreCase(asyncText)) { isAsync = true; isAsyncExclusive = true; } } public void write(Element actionElement) { - if (actionDelegation!=null) { + if (actionDelegation != null) { actionDelegation.write(actionElement); } } @@ -113,31 +121,34 @@ ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader(); try { // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448) - Thread.currentThread().setContextClassLoader(JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); + Thread.currentThread().setContextClassLoader( + JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); if (referencedAction != null) { referencedAction.execute(executionContext); - } else if (actionExpression != null) { + } + else if (actionExpression != null) { JbpmExpressionEvaluator.evaluate(actionExpression, executionContext); - } else if (actionDelegation != null) { + } + else if (actionDelegation != null) { ActionHandler actionHandler = (ActionHandler) actionDelegation.getInstance(); actionHandler.execute(executionContext); } - } finally { + } + finally { Thread.currentThread().setContextClassLoader(surroundingClassLoader); } } public void setName(String name) { // if the process definition is already set - if (processDefinition!=null) { + if (processDefinition != null) { // update the process definition action map Map actionMap = processDefinition.getActions(); // the != string comparison is to avoid null pointer checks. it is no problem if the body is executed a few times too much :-) - if ( (this.name != name) - && (actionMap!=null) ) { + if ((this.name != name) && (actionMap != null)) { actionMap.remove(this.name); actionMap.put(name, this); } @@ -146,14 +157,14 @@ // then update the name this.name = name; } - + // 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) { return EqualsUtil.equals(this, o); } - + // getters and setters ////////////////////////////////////////////////////// public boolean acceptsPropagatedEvents() { @@ -163,6 +174,7 @@ public boolean isPropagationAllowed() { return isPropagationAllowed; } + public void setPropagationAllowed(boolean isPropagationAllowed) { this.isPropagationAllowed = isPropagationAllowed; } @@ -170,45 +182,59 @@ public long getId() { return id; } + public String getName() { return name; } + public Event getEvent() { return event; } + public ProcessDefinition getProcessDefinition() { return processDefinition; } + public void setProcessDefinition(ProcessDefinition processDefinition) { this.processDefinition = processDefinition; } + public Delegation getActionDelegation() { return actionDelegation; } + public void setActionDelegation(Delegation instantiatableDelegate) { this.actionDelegation = instantiatableDelegate; } + public Action getReferencedAction() { return referencedAction; } + public void setReferencedAction(Action referencedAction) { this.referencedAction = referencedAction; } + public boolean isAsync() { return isAsync; } + public boolean isAsyncExclusive() { return isAsyncExclusive; } + public String getActionExpression() { return actionExpression; } + public void setActionExpression(String actionExpression) { this.actionExpression = actionExpression; } + public void setEvent(Event event) { this.event = event; } + public void setAsync(boolean isAsync) { this.isAsync = isAsync; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/EventCallback.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/EventCallback.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/EventCallback.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -23,9 +23,9 @@ import java.io.Serializable; import java.util.HashMap; +import java.util.Iterator; import java.util.Map; -import java.util.concurrent.Semaphore; -import java.util.concurrent.TimeUnit; +import java.util.Map.Entry; import javax.transaction.Status; import javax.transaction.Synchronization; @@ -35,6 +35,7 @@ import org.jbpm.JbpmContext; import org.jbpm.JbpmException; +import org.jbpm.util.Semaphore; public class EventCallback implements Serializable { @@ -43,7 +44,7 @@ private static final long serialVersionUID = 1L; private static final Log log = LogFactory.getLog(EventCallback.class); - private static Map<String, Semaphore> eventSemaphores = new HashMap<String, Semaphore>(); + private static Map eventSemaphores = new HashMap(); public void processStart() { registerNotification(Event.EVENTTYPE_PROCESS_START); @@ -96,10 +97,8 @@ } }; - JbpmContext.getCurrentJbpmContext() - .getSession() - .getTransaction() - .registerSynchronization(notification); + JbpmContext.getCurrentJbpmContext().getSession().getTransaction().registerSynchronization( + notification); } public static void waitForEvent(String event) { @@ -118,7 +117,7 @@ log.debug("waiting for " + event); Semaphore eventSemaphore = getEventSemaphore(event); try { - if (eventSemaphore.tryAcquire(occurrences, timeout, TimeUnit.MILLISECONDS)) { + if (eventSemaphore.tryAcquire(occurrences, timeout)) { log.debug("received '" + event + "' notification"); } else { @@ -132,7 +131,7 @@ private static Semaphore getEventSemaphore(String event) { synchronized (eventSemaphores) { - Semaphore semaphore = eventSemaphores.get(event); + Semaphore semaphore = (Semaphore) eventSemaphores.get(event); if (semaphore == null) { semaphore = new Semaphore(0); eventSemaphores.put(event, semaphore); @@ -142,8 +141,10 @@ } public static void clear() { - for (Map.Entry<String, Semaphore> entry : eventSemaphores.entrySet()) { - int permits = entry.getValue().drainPermits(); + for (Iterator i = eventSemaphores.entrySet().iterator(); i.hasNext();) { + Map.Entry entry = (Entry) i.next(); + Semaphore semaphore = (Semaphore) entry.getValue(); + int permits = semaphore.drainPermits(); if (permits != 0) { log.warn("event '" + entry.getKey() + "' has " + permits + " outstanding notifications"); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -31,6 +31,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.graph.exe.ExecutionContext; @@ -44,6 +45,7 @@ import org.jbpm.signal.EventService; import org.jbpm.svc.Service; import org.jbpm.svc.Services; +import org.jbpm.util.ClassUtil; import org.jbpm.util.EqualsUtil; public abstract class GraphElement implements Identifiable, Serializable { @@ -67,9 +69,9 @@ // events /////////////////////////////////////////////////////////////////// /** - * indicative set of event types supported by this graph element. this is currently only used by the process designer - * to know which event types to show on a given graph element. in process definitions and at runtime, there are no - * contstraints on the event-types. + * indicative set of event types supported by this graph element. this is currently only used by + * the process designer to know which event types to show on a given graph element. in process + * definitions and at runtime, there are no contstraints on the event-types. */ public abstract String[] getSupportedEventTypes(); @@ -168,10 +170,15 @@ && (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 " + + exceptionHandlers); + } } // event handling /////////////////////////////////////////////////////////// @@ -194,7 +201,8 @@ } fireAndPropagateEvent(eventType, executionContext); - } finally { + } + finally { executionContext.setEventSource(null); } } @@ -234,10 +242,12 @@ Action action = (Action) iter.next(); if (action.acceptsPropagatedEvents() || (!isPropagated)) { if (action.isAsync()) { - ExecuteActionJob job = createAsyncActionExecutionJob(executionContext.getToken(), action); + ExecuteActionJob job = createAsyncActionExecutionJob(executionContext.getToken(), + action); MessageService messageService = (MessageService) Services.getCurrentService(Services.SERVICENAME_MESSAGE); messageService.send(job); - } else { + } + else { executeAction(action, executionContext); } } @@ -280,17 +290,20 @@ if (UserCodeInterceptorConfig.userCodeInterceptor != null) { UserCodeInterceptorConfig.userCodeInterceptor.executeAction(action, executionContext); - } else { + } + else { action.execute(executionContext); } - } finally { + } + finally { if (actionMustBeLocked) { token.unlock(lockOwnerId); } } - } catch (Exception exception) { + } + 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); @@ -299,7 +312,8 @@ // if an exception handler is available raiseException(exception, executionContext); - } finally { + } + finally { executionContext.setAction(null); token.endCompositeLog(); } @@ -316,8 +330,7 @@ if ((this.equals(runtimeAction.getGraphElement())) && (eventType.equals(runtimeAction.getEventType()))) { // ... add its action to the list of runtime actions - if (runtimeActionsForEvent == null) - runtimeActionsForEvent = new ArrayList(); + if (runtimeActionsForEvent == null) runtimeActionsForEvent = new ArrayList(); runtimeActionsForEvent.add(runtimeAction.getAction()); } } @@ -326,11 +339,11 @@ } /* - * // the next instruction merges the actions specified in the process definition with the runtime actions List - * actions = event.collectActions(executionContext); + * // the next instruction merges the actions specified in the process definition with the runtime + * actions List actions = event.collectActions(executionContext); * - * // loop over all actions of this event Iterator iter = actions.iterator(); while (iter.hasNext()) { Action action = - * (Action) iter.next(); executionContext.setAction(action); + * // loop over all actions of this event Iterator iter = actions.iterator(); while + * (iter.hasNext()) { Action action = (Action) iter.next(); executionContext.setAction(action); * * if ( (!isPropagated) || (action.acceptsPropagatedEvents() ) ) { * @@ -339,20 +352,22 @@ * * try { // execute the action action.execute(executionContext); * - * } catch (Exception exception) { // NOTE that Error's are not caught because that might halt the JVM and mask the - * original Error. Event.log.error("action threw exception: "+exception.getMessage(), exception); + * } catch (Exception exception) { // NOTE that Error's are not caught because that might halt the + * JVM and mask the original Error. + * Event.log.error("action threw exception: "+exception.getMessage(), exception); * * // log the action exception actionLog.setException(exception); * - * // if an exception handler is available event.graphElement.raiseException(exception, executionContext); } finally { - * executionContext.getToken().endCompositeLog(); } } } } + * // if an exception handler is available event.graphElement.raiseException(exception, + * executionContext); } finally { executionContext.getToken().endCompositeLog(); } } } } */ /** - * throws an ActionException if no applicable exception handler is found. An ExceptionHandler is searched for in this - * graph element and then recursively up the parent hierarchy. If an exception handler is found, it is applied. If the - * 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. + * throws an ActionException if no applicable exception handler is found. An ExceptionHandler is + * searched for in this graph element and then recursively up the parent hierarchy. If an + * exception handler is found, it is applied. If the 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 { @@ -365,7 +380,8 @@ exceptionHandler.handleException(this, executionContext); return; } - } catch (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; @@ -397,15 +413,18 @@ * </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; + /* + * 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 */ + /* + * 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(); @@ -413,7 +432,8 @@ Service service = services.getPersistenceService(); if (service instanceof DbPersistenceService) { DbPersistenceService persistenceService = (DbPersistenceService) service; - return persistenceService.isTransactionActive() || persistenceService.getTransaction() == null; + return persistenceService.isTransactionActive() + || persistenceService.getTransaction() == null; } } } @@ -472,8 +492,8 @@ } public String toString() { - return getClass().getSimpleName() + (name != null ? '(' + name + ')' - : '@' + Integer.toHexString(hashCode())); + return ClassUtil.getSimpleName(getClass()) + + (name != null ? '(' + name + ')' : '@' + Integer.toHexString(hashCode())); } // equals /////////////////////////////////////////////////////////////////// Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Node.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Node.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/Node.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -32,6 +32,7 @@ import java.util.Set; import org.dom4j.Element; + import org.jbpm.JbpmException; import org.jbpm.graph.action.ActionTypes; import org.jbpm.graph.exe.ExecutionContext; @@ -44,47 +45,57 @@ import org.jbpm.svc.Services; import org.jbpm.util.Clock; -public class Node extends GraphElement implements Parsable -{ +public class Node extends GraphElement implements Parsable { private static final long serialVersionUID = 1L; - - public enum NodeType { Node, StartState, EndState, State, Task, Fork, Join, Decision }; - protected List<Transition> leavingTransitions = null; + public static class NodeType { + + private final String name; + + public static final NodeType Node = new NodeType("Node"); + public static final NodeType StartState = new NodeType("StartState"); + public static final NodeType EndState = new NodeType("EndState"); + public static final NodeType State = new NodeType("State"); + public static final NodeType Task = new NodeType("Task"); + public static final NodeType Fork = new NodeType("Fork"); + public static final NodeType Join = new NodeType("Join"); + public static final NodeType Decision = new NodeType("Decision"); + + protected NodeType(String name) { + this.name = name; + } + + public String toString() { + return name; + } + }; + + protected List leavingTransitions = null; transient Map leavingTransitionMap = null; - protected Set<Transition> arrivingTransitions = null; + protected Set arrivingTransitions = null; protected Action action = null; protected SuperState superState = null; protected boolean isAsync = false; protected boolean isAsyncExclusive = false; - - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.Node; } - - public String getNameExt() - { + + public String getNameExt() { String name = super.getName(); - if (name == null) - name = "#anonymous" + getNodeType(); - + if (name == null) name = "#anonymous" + getNodeType(); + return name; } // event types ////////////////////////////////////////////////////////////// - public static final String[] supportedEventTypes = new String[] { - Event.EVENTTYPE_NODE_ENTER, - Event.EVENTTYPE_NODE_LEAVE, - Event.EVENTTYPE_BEFORE_SIGNAL, - Event.EVENTTYPE_AFTER_SIGNAL - }; + public static final String[] supportedEventTypes = new String[] { Event.EVENTTYPE_NODE_ENTER, + Event.EVENTTYPE_NODE_LEAVE, Event.EVENTTYPE_BEFORE_SIGNAL, Event.EVENTTYPE_AFTER_SIGNAL }; - public String[] getSupportedEventTypes() - { + public String[] getSupportedEventTypes() { return supportedEventTypes; } @@ -93,27 +104,22 @@ /** * creates an unnamed node. */ - public Node() - { + public Node() { } /** * creates a node with the given name. */ - public Node(String name) - { + public Node(String name) { super(name); } - public void read(Element nodeElement, JpdlXmlReader jpdlXmlReader) - { + public void read(Element nodeElement, JpdlXmlReader jpdlXmlReader) { action = jpdlXmlReader.readSingleAction(nodeElement); } - public void write(Element nodeElement) - { - if (action != null) - { + public void write(Element nodeElement) { + if (action != null) { String actionName = ActionTypes.getActionName(action.getClass()); Element actionElement = nodeElement.addElement(actionName); action.write(actionElement); @@ -122,29 +128,24 @@ // leaving transitions ////////////////////////////////////////////////////// - public List<Transition> getLeavingTransitions() - { + public List getLeavingTransitions() { return leavingTransitions; } - public List<Transition> getLeavingTransitionsList() - { + public List getLeavingTransitionsList() { return leavingTransitions; } /** * are the leaving {@link Transition}s, mapped by their name (java.lang.String). */ - public Map getLeavingTransitionsMap() - { - if ((leavingTransitionMap == null) && (leavingTransitions != null)) - { + public Map getLeavingTransitionsMap() { + if ((leavingTransitionMap == null) && (leavingTransitions != null)) { // initialize the cached leaving transition map leavingTransitionMap = new HashMap(); ListIterator iter = leavingTransitions.listIterator(leavingTransitions.size()); - while (iter.hasPrevious()) - { - Transition leavingTransition = (Transition)iter.previous(); + while (iter.hasPrevious()) { + Transition leavingTransition = (Transition) iter.previous(); leavingTransitionMap.put(leavingTransition.getName(), leavingTransition); } } @@ -156,12 +157,10 @@ * * @throws IllegalArgumentException if leavingTransition is null. */ - public Transition addLeavingTransition(Transition leavingTransition) - { + public Transition addLeavingTransition(Transition leavingTransition) { if (leavingTransition == null) throw new IllegalArgumentException("can't add a null leaving transition to an node"); - if (leavingTransitions == null) - leavingTransitions = new ArrayList(); + if (leavingTransitions == null) leavingTransitions = new ArrayList(); leavingTransitions.add(leavingTransition); leavingTransition.from = this; leavingTransitionMap = null; @@ -173,14 +172,11 @@ * * @throws IllegalArgumentException if leavingTransition is null. */ - public void removeLeavingTransition(Transition leavingTransition) - { + public void removeLeavingTransition(Transition leavingTransition) { if (leavingTransition == null) throw new IllegalArgumentException("can't remove a null leavingTransition from an node"); - if (leavingTransitions != null) - { - if (leavingTransitions.remove(leavingTransition)) - { + if (leavingTransitions != null) { + if (leavingTransitions.remove(leavingTransition)) { leavingTransition.from = null; leavingTransitionMap = null; } @@ -192,26 +188,21 @@ * * @return true if this node has a leaving transition with the given name, false otherwise. */ - public boolean hasLeavingTransition(String transitionName) - { - if (leavingTransitions == null) - return false; + public boolean hasLeavingTransition(String transitionName) { + if (leavingTransitions == null) return false; return getLeavingTransitionsMap().containsKey(transitionName); } /** - * retrieves a leaving transition by name. note that also the leaving transitions of the supernode are taken into - * account. + * retrieves a leaving transition by name. note that also the leaving transitions of the supernode + * are taken into account. */ - public Transition getLeavingTransition(String transitionName) - { + public Transition getLeavingTransition(String transitionName) { Transition transition = null; - if (leavingTransitions != null) - { - transition = (Transition)getLeavingTransitionsMap().get(transitionName); + if (leavingTransitions != null) { + transition = (Transition) getLeavingTransitionsMap().get(transitionName); } - if ((transition == null) && (superState != null)) - { + if ((transition == null) && (superState != null)) { transition = superState.getLeavingTransition(transitionName); } return transition; @@ -220,19 +211,16 @@ /** * true if this transition has leaving transitions. */ - public boolean hasNoLeavingTransitions() - { + public boolean hasNoLeavingTransitions() { return (((leavingTransitions == null) || (leavingTransitions.size() == 0)) && ((superState == null) || (superState.hasNoLeavingTransitions()))); } /** * generates a new name for a transition that will be added as a leaving transition. */ - public String generateNextLeavingTransitionName() - { + public String generateNextLeavingTransitionName() { String name = null; - if (leavingTransitions != null && containsName(leavingTransitions, null)) - { + if (leavingTransitions != null && containsName(leavingTransitions, null)) { int n = 1; while (containsName(leavingTransitions, Integer.toString(n))) n++; @@ -241,18 +229,14 @@ return name; } - boolean containsName(List leavingTransitions, String name) - { + boolean containsName(List leavingTransitions, String name) { Iterator iter = leavingTransitions.iterator(); - while (iter.hasNext()) - { - Transition transition = (Transition)iter.next(); - if ((name == null) && (transition.getName() == null)) - { + while (iter.hasNext()) { + Transition transition = (Transition) iter.next(); + if ((name == null) && (transition.getName() == null)) { return true; } - else if ((name != null) && (name.equals(transition.getName()))) - { + else if ((name != null) && (name.equals(transition.getName()))) { return true; } } @@ -264,23 +248,19 @@ /** * is the default leaving transition. */ - public Transition getDefaultLeavingTransition() - { + public Transition getDefaultLeavingTransition() { Transition defaultTransition = null; - if (leavingTransitions != null) - { + if (leavingTransitions != null) { // Select the first unconditional transition - for (Transition auxTransition : leavingTransitions) - { - if (auxTransition.getCondition() == null) - { + for (Iterator i = leavingTransitions.iterator(); i.hasNext();) { + Transition auxTransition = (Transition) i.next(); + if (auxTransition.getCondition() == null) { defaultTransition = auxTransition; break; } } } - else if (superState != null) - { + else if (superState != null) { defaultTransition = superState.getDefaultLeavingTransition(); } return defaultTransition; @@ -289,12 +269,12 @@ /** * moves one leaving transition from the oldIndex and inserts it at the newIndex. */ - public void reorderLeavingTransition(int oldIndex, int newIndex) - { - if ((leavingTransitions != null) && (Math.min(oldIndex, newIndex) >= 0) && (Math.max(oldIndex, newIndex) < leavingTransitions.size())) - { - Transition o = leavingTransitions.remove(oldIndex); - leavingTransitions.add(newIndex, o); + public void reorderLeavingTransition(int oldIndex, int newIndex) { + if (leavingTransitions != null + && Math.min(oldIndex, newIndex) >= 0 + && Math.max(oldIndex, newIndex) < leavingTransitions.size()) { + Object transition = leavingTransitions.remove(oldIndex); + leavingTransitions.add(newIndex, transition); } } @@ -303,8 +283,7 @@ /** * are the arriving transitions. */ - public Set<Transition> getArrivingTransitions() - { + public Set getArrivingTransitions() { return arrivingTransitions; } @@ -313,12 +292,10 @@ * * @throws IllegalArgumentException if t is null. */ - public Transition addArrivingTransition(Transition arrivingTransition) - { + public Transition addArrivingTransition(Transition arrivingTransition) { if (arrivingTransition == null) throw new IllegalArgumentException("can't add a null arrivingTransition to a node"); - if (arrivingTransitions == null) - arrivingTransitions = new HashSet(); + if (arrivingTransitions == null) arrivingTransitions = new HashSet(); arrivingTransitions.add(arrivingTransition); arrivingTransition.to = this; return arrivingTransition; @@ -329,14 +306,11 @@ * * @throws IllegalArgumentException if t is null. */ - public void removeArrivingTransition(Transition arrivingTransition) - { + public void removeArrivingTransition(Transition arrivingTransition) { if (arrivingTransition == null) throw new IllegalArgumentException("can't remove a null arrivingTransition from a node"); - if (arrivingTransitions != null) - { - if (arrivingTransitions.remove(arrivingTransition)) - { + if (arrivingTransitions != null) { + if (arrivingTransitions.remove(arrivingTransition)) { arrivingTransition.to = null; } } @@ -347,11 +321,9 @@ /** * is the {@link SuperState} or the {@link ProcessDefinition} in which this node is contained. */ - public GraphElement getParent() - { + public GraphElement getParent() { GraphElement parent = processDefinition; - if (superState != null) - parent = superState; + if (superState != null) parent = superState; return parent; } @@ -360,8 +332,7 @@ /** * called by a transition to pass execution to this node. */ - public void enter(ExecutionContext executionContext) - { + public void enter(ExecutionContext executionContext) { Token token = executionContext.getToken(); // update the runtime context information @@ -378,21 +349,18 @@ executionContext.setTransitionSource(null); // execute the node - if (isAsync) - { + if (isAsync) { ExecuteNodeJob job = createAsyncContinuationJob(token); - MessageService messageService = (MessageService)Services.getCurrentService(Services.SERVICENAME_MESSAGE); + MessageService messageService = (MessageService) Services.getCurrentService(Services.SERVICENAME_MESSAGE); messageService.send(job); token.lock(job.toString()); } - else - { + else { execute(executionContext); } } - protected ExecuteNodeJob createAsyncContinuationJob(Token token) - { + protected ExecuteNodeJob createAsyncContinuationJob(Token token) { ExecuteNodeJob job = new ExecuteNodeJob(token); job.setNode(this); job.setDueDate(new Date()); @@ -403,27 +371,22 @@ /** * override this method to customize the node behaviour. */ - public void execute(ExecutionContext executionContext) - { + public void execute(ExecutionContext executionContext) { // if there is a custom action associated with this node - if (action != null) - { - try - { + if (action != null) { + try { // execute the action executeAction(action, executionContext); } - catch (Exception exception) - { + catch (Exception exception) { // NOTE that Error's are not caught because that might halt the JVM and mask the original Error. // search for an exception handler or throw to the client raiseException(exception, executionContext); } } - else - { + else { // let this node handle the token // the default behaviour is to leave the node over the default transition. leave(executionContext); @@ -433,20 +396,21 @@ /** * called by the implementation of this node to continue execution over the default transition. */ - public void leave(ExecutionContext executionContext) - { + public void leave(ExecutionContext executionContext) { leave(executionContext, getDefaultLeavingTransition()); } /** * called by the implementation of this node to continue execution over the specified transition. */ - public void leave(ExecutionContext executionContext, String transitionName) - { + public void leave(ExecutionContext executionContext, String transitionName) { Transition transition = getLeavingTransition(transitionName); - if (transition == null) - { - throw new JbpmException("transition '" + transitionName + "' is not a leaving transition of node '" + this + "'"); + if (transition == null) { + throw new JbpmException("transition '" + + transitionName + + "' is not a leaving transition of node '" + + this + + "'"); } leave(executionContext, transition); } @@ -454,8 +418,7 @@ /** * called by the implementation of this node to continue execution over the given transition. */ - public void leave(ExecutionContext executionContext, Transition transition) - { + public void leave(ExecutionContext executionContext, Transition transition) { if (transition == null) throw new JbpmException("can't leave node '" + this + "' without leaving transition"); Token token = executionContext.getToken(); @@ -466,8 +429,7 @@ fireEvent(Event.EVENTTYPE_NODE_LEAVE, executionContext); // log this node - if (token.getNodeEnter() != null) - { + if (token.getNodeEnter() != null) { addNodeLog(token); } @@ -479,18 +441,15 @@ transition.take(executionContext); } - protected void addNodeLog(Token token) - { + protected void addNodeLog(Token token) { token.addLog(new NodeLog(this, token.getNodeEnter(), Clock.getCurrentTime())); } // /////////////////////////////////////////////////////////////////////////// - public ProcessDefinition getProcessDefinition() - { + public ProcessDefinition getProcessDefinition() { ProcessDefinition pd = this.processDefinition; - if (superState != null) - { + if (superState != null) { pd = superState.getProcessDefinition(); } return pd; @@ -500,28 +459,30 @@ /** * updates the name of this node */ - public void setName(String name) - { - if (isDifferent(this.name, name)) - { + public void setName(String name) { + if (isDifferent(this.name, name)) { String oldName = this.name; - if (superState != null) - { - if (superState.hasNode(name)) - { - throw new IllegalArgumentException("couldn't set name '" + name + "' on node '" + this - + "'cause the superState of this node has already another child node with the same name"); + if (superState != null) { + if (superState.hasNode(name)) { + throw new IllegalArgumentException( + "couldn't set name '" + + name + + "' on node '" + + this + + "'cause the superState of this node has already another child node with the same name"); } Map nodes = superState.getNodesMap(); nodes.remove(oldName); nodes.put(name, this); } - else if (processDefinition != null) - { - if (processDefinition.hasNode(name)) - { - throw new IllegalArgumentException("couldn't set name '" + name + "' on node '" + this - + "'cause the process definition of this node has already another node with the same name"); + else if (processDefinition != null) { + if (processDefinition.hasNode(name)) { + throw new IllegalArgumentException( + "couldn't set name '" + + name + + "' on node '" + + this + + "'cause the process definition of this node has already another node with the same name"); } Map nodeMap = processDefinition.getNodesMap(); nodeMap.remove(oldName); @@ -531,14 +492,11 @@ } } - boolean isDifferent(String name1, String name2) - { - if ((name1 != null) && (name1.equals(name2))) - { + boolean isDifferent(String name1, String name2) { + if ((name1 != null) && (name1.equals(name2))) { return false; } - else if ((name1 == null) && (name2 == null)) - { + else if ((name1 == null) && (name2 == null)) { return false; } return true; @@ -547,62 +505,51 @@ /** * the slash separated name that includes all the superstate names. */ - public String getFullyQualifiedName() - { + public String getFullyQualifiedName() { String fullyQualifiedName = name; - if (superState != null) - { + if (superState != null) { fullyQualifiedName = superState.getFullyQualifiedName() + "/" + name; } return fullyQualifiedName; } /** indicates wether this node is a superstate. */ - public boolean isSuperStateNode() - { + public boolean isSuperStateNode() { return false; } /** returns a list of child nodes (only applicable for {@link SuperState})s. */ - public List getNodes() - { + public List getNodes() { return null; } // getters and setters ////////////////////////////////////////////////////// - public SuperState getSuperState() - { + public SuperState getSuperState() { return superState; } - public Action getAction() - { + public Action getAction() { return action; } - public void setAction(Action action) - { + public void setAction(Action action) { this.action = action; } - public boolean isAsync() - { + public boolean isAsync() { return isAsync; } - public void setAsync(boolean isAsync) - { + public void setAsync(boolean isAsync) { this.isAsync = isAsync; } - public boolean isAsyncExclusive() - { + public boolean isAsyncExclusive() { return isAsyncExclusive; } - public void setAsyncExclusive(boolean isAsyncExclusive) - { + public void setAsyncExclusive(boolean isAsyncExclusive) { this.isAsyncExclusive = isAsyncExclusive; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -35,6 +35,8 @@ import java.util.StringTokenizer; import java.util.zip.ZipInputStream; +import org.xml.sax.InputSource; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmException; import org.jbpm.context.def.ContextDefinition; @@ -48,40 +50,29 @@ import org.jbpm.module.def.ModuleDefinition; import org.jbpm.taskmgmt.def.TaskMgmtDefinition; import org.jbpm.util.ClassLoaderUtil; -import org.xml.sax.InputSource; public class ProcessDefinition extends GraphElement implements NodeCollection { private static final long serialVersionUID = 1L; - + protected int version = -1; protected boolean isTerminationImplicit = false; protected Node startState = null; - protected List<Node> nodes = null; + protected List nodes = null; transient Map nodesMap = null; protected Map actions = null; protected Map definitions = null; // event types ////////////////////////////////////////////////////////////// - public static final String[] supportedEventTypes = new String[]{ - Event.EVENTTYPE_PROCESS_START, - Event.EVENTTYPE_PROCESS_END, - Event.EVENTTYPE_NODE_ENTER, - Event.EVENTTYPE_NODE_LEAVE, - Event.EVENTTYPE_TASK_CREATE, - Event.EVENTTYPE_TASK_ASSIGN, - Event.EVENTTYPE_TASK_START, - Event.EVENTTYPE_TASK_END, - Event.EVENTTYPE_TRANSITION, - Event.EVENTTYPE_BEFORE_SIGNAL, - Event.EVENTTYPE_AFTER_SIGNAL, - Event.EVENTTYPE_SUPERSTATE_ENTER, - Event.EVENTTYPE_SUPERSTATE_LEAVE, - Event.EVENTTYPE_SUBPROCESS_CREATED, - Event.EVENTTYPE_SUBPROCESS_END, - Event.EVENTTYPE_TIMER - }; + public static final String[] supportedEventTypes = new String[] { Event.EVENTTYPE_PROCESS_START, + Event.EVENTTYPE_PROCESS_END, Event.EVENTTYPE_NODE_ENTER, Event.EVENTTYPE_NODE_LEAVE, + Event.EVENTTYPE_TASK_CREATE, Event.EVENTTYPE_TASK_ASSIGN, Event.EVENTTYPE_TASK_START, + Event.EVENTTYPE_TASK_END, Event.EVENTTYPE_TRANSITION, Event.EVENTTYPE_BEFORE_SIGNAL, + Event.EVENTTYPE_AFTER_SIGNAL, Event.EVENTTYPE_SUPERSTATE_ENTER, + Event.EVENTTYPE_SUPERSTATE_LEAVE, Event.EVENTTYPE_SUBPROCESS_CREATED, + Event.EVENTTYPE_SUBPROCESS_END, Event.EVENTTYPE_TIMER }; + public String[] getSupportedEventTypes() { return supportedEventTypes; } @@ -94,7 +85,7 @@ public static ProcessDefinition createNewProcessDefinition() { ProcessDefinition processDefinition = new ProcessDefinition(); - + // now add all the default modules that are configured in the file jbpm.default.modules String resource = JbpmConfiguration.Configs.getString("resource.default.modules"); Properties defaultModulesProperties = ClassLoaderUtil.getProperties(resource); @@ -102,12 +93,14 @@ while (iter.hasNext()) { String moduleClassName = (String) iter.next(); try { - ModuleDefinition moduleDefinition = (ModuleDefinition) ClassLoaderUtil.loadClass(moduleClassName).newInstance(); + ModuleDefinition moduleDefinition = (ModuleDefinition) ClassLoaderUtil.loadClass( + moduleClassName).newInstance(); processDefinition.addDefinition(moduleDefinition); - - } catch (Exception e) { - throw new JbpmException("couldn't instantiate default module '"+moduleClassName+"'", e); + } + catch (Exception e) { + throw new JbpmException("couldn't instantiate default module '" + moduleClassName + "'", e); + } } return processDefinition; } @@ -135,15 +128,17 @@ } public void setProcessDefinition(ProcessDefinition processDefinition) { - if (! this.equals(processDefinition)) { - throw new JbpmException("can't set the process-definition-property of a process defition to something else then a self-reference"); + if (!this.equals(processDefinition)) { + throw new JbpmException( + "can't set the process-definition-property of a process defition to something else then a self-reference"); } } // parsing ////////////////////////////////////////////////////////////////// - + /** * parse a process definition from an xml string. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlString(String xml) { @@ -154,6 +149,7 @@ /** * parse a process definition from an xml resource file. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlResource(String xmlResource) { @@ -161,21 +157,23 @@ if (resourceURL == null) { throw new JpdlException("resource not found: " + xmlResource); } - JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(resourceURL.toString())); + JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(resourceURL.toString())); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from an xml input stream. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlInputStream(InputStream inputStream) { - JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(inputStream)); + JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(inputStream)); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from an xml reader. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlReader(Reader reader) { @@ -185,14 +183,17 @@ /** * parse a process definition from a process archive zip-stream. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ - public static ProcessDefinition parseParZipInputStream(ZipInputStream zipInputStream) throws IOException { + public static ProcessDefinition parseParZipInputStream(ZipInputStream zipInputStream) + throws IOException { return new ProcessArchive(zipInputStream).parseProcessDefinition(); } /** * parse a process definition from a process archive resource. + * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseParResource(String parResource) throws IOException { @@ -202,19 +203,19 @@ // nodes //////////////////////////////////////////////////////////////////// // javadoc description in NodeCollection - public List<Node> getNodes() { + public List getNodes() { return nodes; } // javadoc description in NodeCollection public Map getNodesMap() { - if (nodesMap==null) { + if (nodesMap == null) { nodesMap = new HashMap(); - if (nodes!=null) { + if (nodes != null) { Iterator iter = nodes.iterator(); while (iter.hasNext()) { Node node = (Node) iter.next(); - nodesMap.put(node.getName(),node); + nodesMap.put(node.getName(), node); } } } @@ -223,27 +224,26 @@ // javadoc description in NodeCollection public Node getNode(String name) { - if (nodes==null) return null; + if (nodes == null) return null; return (Node) getNodesMap().get(name); } // javadoc description in NodeCollection public boolean hasNode(String name) { - if (nodes==null) return false; + if (nodes == null) return false; return getNodesMap().containsKey(name); } // javadoc description in NodeCollection public Node addNode(Node node) { - if (node == null) throw new IllegalArgumentException("can't add a null node to a processdefinition"); + if (node == null) + throw new IllegalArgumentException("can't add a null node to a processdefinition"); if (nodes == null) nodes = new ArrayList(); nodes.add(node); node.processDefinition = this; nodesMap = null; - - if( (node instanceof StartState) - && (this.startState==null) - ) { + + if ((node instanceof StartState) && (this.startState == null)) { this.startState = node; } return node; @@ -252,7 +252,8 @@ // javadoc description in NodeCollection public Node removeNode(Node node) { Node removedNode = null; - if (node == null) throw new IllegalArgumentException("can't remove a null node from a process definition"); + if (node == null) + throw new IllegalArgumentException("can't remove a null node from a process definition"); if (nodes != null) { if (nodes.remove(node)) { removedNode = node; @@ -260,8 +261,8 @@ nodesMap = null; } } - - if (startState==removedNode) { + + if (startState == removedNode) { startState = null; } return removedNode; @@ -269,14 +270,18 @@ // javadoc description in NodeCollection public void reorderNode(int oldIndex, int newIndex) { - if ( (nodes!=null) - && (Math.min(oldIndex, newIndex)>=0) - && (Math.max(oldIndex, newIndex)<nodes.size()) ) { - Node o = nodes.remove(oldIndex); - nodes.add(newIndex, o); - } else { - throw new IndexOutOfBoundsException("couldn't reorder element from index '"+oldIndex+"' to index '"+newIndex+"' in nodeList '"+nodes+"'"); + if (nodes != null + && Math.min(oldIndex, newIndex) >= 0 + && Math.max(oldIndex, newIndex) < nodes.size()) { + Object node = nodes.remove(oldIndex); + nodes.add(newIndex, node); } + else { + throw new IndexOutOfBoundsException("couldn't reorder element from index " + + oldIndex + + " to index " + + newIndex); + } } // javadoc description in NodeCollection @@ -291,11 +296,13 @@ public static String generateNodeName(List nodes) { String name = null; - if (nodes==null) { + if (nodes == null) { name = "1"; - } else { + } + else { int n = 1; - while (containsName(nodes, Integer.toString(n))) n++; + while (containsName(nodes, Integer.toString(n))) + n++; name = Integer.toString(n); } return name; @@ -305,7 +312,7 @@ Iterator iter = nodes.iterator(); while (iter.hasNext()) { Node node = (Node) iter.next(); - if ( name.equals(node.getName()) ) { + if (name.equals(node.getName())) { return true; } } @@ -314,38 +321,40 @@ public static Node findNode(NodeCollection nodeCollection, String hierarchicalName) { Node node = null; - if ((hierarchicalName != null) && (!"".equals(hierarchicalName.trim())) ) { - - if ( (hierarchicalName.startsWith("/")) - && (nodeCollection instanceof SuperState) ){ - nodeCollection = ((SuperState)nodeCollection).getProcessDefinition(); + if ((hierarchicalName != null) && (!"".equals(hierarchicalName.trim()))) { + + if ((hierarchicalName.startsWith("/")) && (nodeCollection instanceof SuperState)) { + nodeCollection = ((SuperState) nodeCollection).getProcessDefinition(); } StringTokenizer tokenizer = new StringTokenizer(hierarchicalName, "/"); while (tokenizer.hasMoreElements()) { String namePart = tokenizer.nextToken(); - if ("..".equals(namePart) ) { + if ("..".equals(namePart)) { if (nodeCollection instanceof ProcessDefinition) { - throw new JbpmException("couldn't find node '"+hierarchicalName+"' because of a '..' on the process definition."); + throw new JbpmException("couldn't find node '" + + hierarchicalName + + "' because of a '..' on the process definition."); } - nodeCollection = (NodeCollection) ((GraphElement)nodeCollection).getParent(); - } else if ( tokenizer.hasMoreElements() ) { - nodeCollection = (NodeCollection)nodeCollection.getNode(namePart); - } else { + nodeCollection = (NodeCollection) ((GraphElement) nodeCollection).getParent(); + } + else if (tokenizer.hasMoreElements()) { + nodeCollection = (NodeCollection) nodeCollection.getNode(namePart); + } + else { node = nodeCollection.getNode(namePart); } } } return node; } - + public void setStartState(StartState startState) { - if ( (this.startState!=startState) - && (this.startState!=null) ){ + if ((this.startState != startState) && (this.startState != null)) { removeNode(this.startState); } this.startState = startState; - if (startState!=null) { + if (startState != null) { addNode(startState); } } @@ -358,11 +367,14 @@ /** * creates a bidirectional relation between this process definition and the given action. + * * @throws IllegalArgumentException if action is null or if action.getName() is null. */ public Action addAction(Action action) { - if (action == null) throw new IllegalArgumentException("can't add a null action to an process definition"); - if (action.getName() == null) throw new IllegalArgumentException("can't add an unnamed action to an process definition"); + if (action == null) + throw new IllegalArgumentException("can't add a null action to an process definition"); + if (action.getName() == null) + throw new IllegalArgumentException("can't add an unnamed action to an process definition"); if (actions == null) actions = new HashMap(); actions.put(action.getName(), action); action.processDefinition = this; @@ -371,13 +383,17 @@ /** * removes the bidirectional relation between this process definition and the given action. - * @throws IllegalArgumentException if action is null or if the action was not present in the actions of this process definition. + * + * @throws IllegalArgumentException if action is null or if the action was not present in the + * actions of this process definition. */ public void removeAction(Action action) { - if (action == null) throw new IllegalArgumentException("can't remove a null action from an process definition"); + if (action == null) + throw new IllegalArgumentException("can't remove a null action from an process definition"); if (actions != null) { - if (! actions.containsValue(action)) { - throw new IllegalArgumentException("can't remove an action that is not part of this process definition"); + if (!actions.containsValue(action)) { + throw new IllegalArgumentException( + "can't remove an action that is not part of this process definition"); } actions.remove(action.getName()); action.processDefinition = null; @@ -388,14 +404,13 @@ if (actions == null) return null; return (Action) actions.get(name); } - + public Map getActions() { return actions; } public boolean hasActions() { - return ( (actions!=null) - && (actions.size()>0) ); + return ((actions != null) && (actions.size() > 0)); } // module definitions /////////////////////////////////////////////////////// @@ -405,20 +420,24 @@ } public ModuleDefinition addDefinition(ModuleDefinition moduleDefinition) { - if (moduleDefinition == null) throw new IllegalArgumentException("can't add a null moduleDefinition to a process definition"); - if (definitions == null) - definitions = new HashMap(); + if (moduleDefinition == null) + throw new IllegalArgumentException( + "can't add a null moduleDefinition to a process definition"); + if (definitions == null) definitions = new HashMap(); definitions.put(moduleDefinition.getClass().getName(), moduleDefinition); moduleDefinition.setProcessDefinition(this); return moduleDefinition; } - + public ModuleDefinition removeDefinition(ModuleDefinition moduleDefinition) { ModuleDefinition removedDefinition = null; - if (moduleDefinition == null) throw new IllegalArgumentException("can't remove a null moduleDefinition from a process definition"); + if (moduleDefinition == null) + throw new IllegalArgumentException( + "can't remove a null moduleDefinition from a process definition"); if (definitions != null) { - removedDefinition = (ModuleDefinition) definitions.remove(moduleDefinition.getClass().getName()); - if (removedDefinition!=null) { + removedDefinition = (ModuleDefinition) definitions.remove(moduleDefinition.getClass() + .getName()); + if (removedDefinition != null) { moduleDefinition.setProcessDefinition(null); } } @@ -432,7 +451,7 @@ } return moduleDefinition; } - + public ContextDefinition getContextDefinition() { return (ContextDefinition) getDefinition(ContextDefinition.class); } @@ -440,6 +459,7 @@ public FileDefinition getFileDefinition() { return (FileDefinition) getDefinition(FileDefinition.class); } + public TaskMgmtDefinition getTaskMgmtDefinition() { return (TaskMgmtDefinition) getDefinition(TaskMgmtDefinition.class); } @@ -465,7 +485,7 @@ public Node getStartState() { return startState; } - + public void setStartState(Node startState) { this.startState = startState; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -33,7 +33,6 @@ import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.context.exe.ContextInstance; -import org.jbpm.db.JobSession; import org.jbpm.graph.def.Event; import org.jbpm.graph.def.Identifiable; import org.jbpm.graph.def.Node; @@ -54,12 +53,10 @@ import org.jbpm.util.EqualsUtil; /** - * is one execution of a {@link org.jbpm.graph.def.ProcessDefinition}. To create a new process execution of a process - * definition, just use the {@link #ProcessInstance(ProcessDefinition)}. - * + * is one execution of a {@link org.jbpm.graph.def.ProcessDefinition}. To create a new process + * execution of a process definition, just use the {@link #ProcessInstance(ProcessDefinition)}. */ -public class ProcessInstance implements Identifiable, Serializable -{ +public class ProcessInstance implements Identifiable, Serializable { private static final long serialVersionUID = 1L; @@ -80,53 +77,51 @@ // constructors ///////////////////////////////////////////////////////////// - public ProcessInstance() - { + public ProcessInstance() { } /** - * creates a new process instance for the given process definition, puts the root-token (=main path of execution) in - * the start state and executes the initial node. In case the initial node is a start-state, it will behave as a wait - * state. For each of the optional module definitions contained in the {@link ProcessDefinition}, the corresponding - * module instance will be created. + * creates a new process instance for the given process definition, puts the root-token (=main + * path of execution) in the start state and executes the initial node. In case the initial node + * is a start-state, it will behave as a wait state. For each of the optional module definitions + * contained in the {@link ProcessDefinition}, the corresponding module instance will be created. * * @throws JbpmException if processDefinition is null. */ - public ProcessInstance(ProcessDefinition processDefinition) - { + public ProcessInstance(ProcessDefinition processDefinition) { this(processDefinition, null, null); } /** - * creates a new process instance for the given process definition, puts the root-token (=main path of execution) in - * the start state and executes the initial node. In case the initial node is a start-state, it will behave as a wait - * state. For each of the optional module definitions contained in the {@link ProcessDefinition}, the corresponding - * module instance will be created. + * creates a new process instance for the given process definition, puts the root-token (=main + * path of execution) in the start state and executes the initial node. In case the initial node + * is a start-state, it will behave as a wait state. For each of the optional module definitions + * contained in the {@link ProcessDefinition}, the corresponding module instance will be created. * - * @param variables will be inserted into the context variables after the context submodule has been created and - * before the process-start event is fired, which is also before the execution of the initial node. + * @param variables will be inserted into the context variables after the context submodule has + * been created and before the process-start event is fired, which is also before the + * execution of the initial node. * @throws JbpmException if processDefinition is null. */ - public ProcessInstance(ProcessDefinition processDefinition, Map variables) - { + public ProcessInstance(ProcessDefinition processDefinition, Map variables) { this(processDefinition, variables, null); } /** - * creates a new process instance for the given process definition, puts the root-token (=main path of execution) in - * the start state and executes the initial node. In case the initial node is a start-state, it will behave as a wait - * state. For each of the optional module definitions contained in the {@link ProcessDefinition}, the corresponding - * module instance will be created. + * creates a new process instance for the given process definition, puts the root-token (=main + * path of execution) in the start state and executes the initial node. In case the initial node + * is a start-state, it will behave as a wait state. For each of the optional module definitions + * contained in the {@link ProcessDefinition}, the corresponding module instance will be created. * - * @param variables will be inserted into the context variables after the context submodule has been created and - * before the process-start event is fired, which is also before the execution of the initial node. + * @param variables will be inserted into the context variables after the context submodule has + * been created and before the process-start event is fired, which is also before the + * execution of the initial node. * @throws JbpmException if processDefinition is null. */ - public ProcessInstance(ProcessDefinition processDefinition, Map variables, String key) - { - if (processDefinition == null) + public ProcessInstance(ProcessDefinition processDefinition, Map variables, String key) { + if (processDefinition == null) { throw new JbpmException("can't create a process instance when processDefinition is null"); - + } // initialize the members this.processDefinition = processDefinition; this.rootToken = new Token(this); @@ -148,44 +143,35 @@ fireStartEvent(initialNode); } - public void addInitialContextVariables(Map variables) - { + public void addInitialContextVariables(Map variables) { ContextInstance contextInstance = getContextInstance(); - if ((contextInstance != null) && (variables != null)) - { + if ((contextInstance != null) && (variables != null)) { contextInstance.addVariables(variables); } } - public void addInitialModuleDefinitions(ProcessDefinition processDefinition) - { + public void addInitialModuleDefinitions(ProcessDefinition processDefinition) { Map definitions = processDefinition.getDefinitions(); // if the state-definition has optional definitions - if (definitions != null) - { + if (definitions != null) { instances = new HashMap(); // loop over each optional definition - Iterator iter = definitions.values().iterator(); - while (iter.hasNext()) - { - ModuleDefinition definition = (ModuleDefinition)iter.next(); + for (Iterator i = definitions.values().iterator(); i.hasNext();) { + ModuleDefinition definition = (ModuleDefinition) i.next(); // and create the corresponding optional instance ModuleInstance instance = definition.createInstance(); - if (instance != null) - { + if (instance != null) { addInstance(instance); } } } } - public void fireStartEvent(Node initialNode) - { + public void fireStartEvent(Node initialNode) { this.start = Clock.getCurrentTime(); - + // fire the process start event - if (initialNode != null) - { + if (initialNode != null) { ExecutionContext executionContext = new ExecutionContext(rootToken); processDefinition.fireEvent(Event.EVENTTYPE_PROCESS_START, executionContext); @@ -199,12 +185,11 @@ /** * adds the given optional moduleinstance (bidirectional). */ - public ModuleInstance addInstance(ModuleInstance moduleInstance) - { - if (moduleInstance == null) + public ModuleInstance addInstance(ModuleInstance moduleInstance) { + if (moduleInstance == null) { throw new IllegalArgumentException("can't add a null moduleInstance to a process instance"); - if (instances == null) - instances = new HashMap(); + } + if (instances == null) instances = new HashMap(); instances.put(moduleInstance.getClass().getName(), moduleInstance); moduleInstance.setProcessInstance(this); return moduleInstance; @@ -213,16 +198,15 @@ /** * removes the given optional moduleinstance (bidirectional). */ - public ModuleInstance removeInstance(ModuleInstance moduleInstance) - { + public ModuleInstance removeInstance(ModuleInstance moduleInstance) { ModuleInstance removedModuleInstance = null; - if (moduleInstance == null) - throw new IllegalArgumentException("can't remove a null moduleInstance from a process instance"); - if (instances != null) - { - removedModuleInstance = (ModuleInstance)instances.remove(moduleInstance.getClass().getName()); - if (removedModuleInstance != null) - { + if (moduleInstance == null) { + throw new IllegalArgumentException( + "can't remove a null moduleInstance from a process instance"); + } + if (instances != null) { + removedModuleInstance = (ModuleInstance) instances.remove(moduleInstance.getClass().getName()); + if (removedModuleInstance != null) { moduleInstance.setProcessInstance(null); } } @@ -232,33 +216,28 @@ /** * looks up an optional module instance by its class. */ - public ModuleInstance getInstance(Class clazz) - { + public ModuleInstance getInstance(Class clazz) { ModuleInstance moduleInstance = null; - if (instances != null) - { - moduleInstance = (ModuleInstance)instances.get(clazz.getName()); + if (instances != null) { + moduleInstance = (ModuleInstance) instances.get(clazz.getName()); } - if (moduleInstance == null) - { - if (transientInstances == null) - transientInstances = new HashMap(); + if (moduleInstance == null) { + if (transientInstances == null) transientInstances = new HashMap(); // client requested an instance that is not in the map of instances. // so we can safely assume that the client wants a transient instance - moduleInstance = (ModuleInstance)transientInstances.get(clazz.getName()); - if (moduleInstance == null) - { - try - { - moduleInstance = (ModuleInstance)clazz.newInstance(); + moduleInstance = (ModuleInstance) transientInstances.get(clazz.getName()); + if (moduleInstance == null) { + try { + moduleInstance = (ModuleInstance) clazz.newInstance(); moduleInstance.setProcessInstance(this); } - catch (Exception e) - { - throw new JbpmException("couldn't instantiate transient module '" + clazz.getName() + "' with the default constructor"); + catch (Exception e) { + throw new JbpmException("couldn't instantiate transient module '" + + clazz.getName() + + "' with the default constructor"); } transientInstances.put(clazz.getName(), moduleInstance); } @@ -270,67 +249,61 @@ /** * process instance extension for process variableInstances. */ - public ContextInstance getContextInstance() - { - return (ContextInstance)getInstance(ContextInstance.class); + public ContextInstance getContextInstance() { + return (ContextInstance) getInstance(ContextInstance.class); } /** * process instance extension for managing the tasks and actors. */ - public TaskMgmtInstance getTaskMgmtInstance() - { - return (TaskMgmtInstance)getInstance(TaskMgmtInstance.class); + public TaskMgmtInstance getTaskMgmtInstance() { + return (TaskMgmtInstance) getInstance(TaskMgmtInstance.class); } /** - * process instance extension for logging. Probably you don't need to access the logging instance directly. Mostly, - * {@link Token#addLog(ProcessLog)} is sufficient and more convenient. + * process instance extension for logging. Probably you don't need to access the logging instance + * directly. Mostly, {@link Token#addLog(ProcessLog)} is sufficient and more convenient. */ - public LoggingInstance getLoggingInstance() - { - return (LoggingInstance)getInstance(LoggingInstance.class); + public LoggingInstance getLoggingInstance() { + return (LoggingInstance) getInstance(LoggingInstance.class); } // operations /////////////////////////////////////////////////////////////// /** - * instructs the main path of execution to continue by taking the default transition on the current node. + * instructs the main path of execution to continue by taking the default transition on the + * current node. * * @throws IllegalStateException if the token is not active. */ - public void signal() - { - if (hasEnded()) - { + public void signal() { + if (hasEnded()) { throw new IllegalStateException("couldn't signal token : token has ended"); } rootToken.signal(); } /** - * instructs the main path of execution to continue by taking the specified transition on the current node. + * instructs the main path of execution to continue by taking the specified transition on the + * current node. * * @throws IllegalStateException if the token is not active. */ - public void signal(String transitionName) - { - if (hasEnded()) - { + public void signal(String transitionName) { + if (hasEnded()) { throw new IllegalStateException("couldn't signal token : token has ended"); } rootToken.signal(transitionName); } /** - * instructs the main path of execution to continue by taking the specified transition on the current node. + * instructs the main path of execution to continue by taking the specified transition on the + * current node. * * @throws IllegalStateException if the token is not active. */ - public void signal(Transition transition) - { - if (hasEnded()) - { + public void signal(Transition transition) { + if (hasEnded()) { throw new IllegalStateException("couldn't signal token : token has ended"); } rootToken.signal(transition); @@ -339,13 +312,11 @@ /** * ends (=cancels) this process instance and all the tokens in it. */ - public void end() - { + public void end() { // end the main path of execution rootToken.end(); - if (end == null) - { + if (end == null) { // mark this process instance as ended end = Clock.getCurrentTime(); @@ -357,8 +328,7 @@ rootToken.addLog(new ProcessInstanceEndLog()); // check if this process was started as a subprocess of a super process - if (superProcessToken != null && !superProcessToken.hasEnded()) - { + if (superProcessToken != null && !superProcessToken.hasEnded()) { addCascadeProcessInstance(superProcessToken.getProcessInstance()); ExecutionContext superExecutionContext = new ExecutionContext(superProcessToken); @@ -369,15 +339,13 @@ // make sure jobs for this process instance are canceled // after the process end updates are posted to the database JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext(); - if (jbpmContext != null) - { + if (jbpmContext != null) { Services services = jbpmContext.getServices(); MessageService messageService = services.getMessageService(); PersistenceService persistenceService = services.getPersistenceService(); if (messageService != null && persistenceService != null - && persistenceService.getJobSession().countDeletableJobsForProcessInstance(this) > 0) - { + && persistenceService.getJobSession().countDeletableJobsForProcessInstance(this) > 0) { CleanUpProcessJob job = new CleanUpProcessJob(rootToken); job.setDueDate(new Date()); messageService.send(job); @@ -387,26 +355,24 @@ } /** - * suspends this execution. This will make sure that tasks, timers and messages related to this process instance will - * not show up in database queries. + * suspends this execution. This will make sure that tasks, timers and messages related to this + * process instance will not show up in database queries. * * @see #resume() */ - public void suspend() - { + public void suspend() { isSuspended = true; rootToken.suspend(); } /** - * resumes a suspended execution. All timers that have been suspended might fire if the duedate has been passed. If an - * admin resumes a process instance, the option should be offered to update, remove and create the timers and messages - * related to this process instance. + * resumes a suspended execution. All timers that have been suspended might fire if the duedate + * has been passed. If an admin resumes a process instance, the option should be offered to + * update, remove and create the timers and messages related to this process instance. * * @see #suspend() */ - public void resume() - { + public void resume() { isSuspended = false; rootToken.resume(); } @@ -416,12 +382,11 @@ /** * adds an action to be executed upon a process event in the future. */ - public RuntimeAction addRuntimeAction(RuntimeAction runtimeAction) - { - if (runtimeAction == null) + public RuntimeAction addRuntimeAction(RuntimeAction runtimeAction) { + if (runtimeAction == null) { throw new IllegalArgumentException("can't add a null runtimeAction to a process instance"); - if (runtimeActions == null) - runtimeActions = new ArrayList(); + } + if (runtimeActions == null) runtimeActions = new ArrayList(); runtimeActions.add(runtimeAction); runtimeAction.processInstance = this; return runtimeAction; @@ -430,15 +395,14 @@ /** * removes a runtime action. */ - public RuntimeAction removeRuntimeAction(RuntimeAction runtimeAction) - { + public RuntimeAction removeRuntimeAction(RuntimeAction runtimeAction) { RuntimeAction removedRuntimeAction = null; - if (runtimeAction == null) - throw new IllegalArgumentException("can't remove a null runtimeAction from an process instance"); - if (runtimeActions != null) - { - if (runtimeActions.remove(runtimeAction)) - { + if (runtimeAction == null) { + throw new IllegalArgumentException( + "can't remove a null runtimeAction from an process instance"); + } + if (runtimeActions != null) { + if (runtimeActions.remove(runtimeAction)) { removedRuntimeAction = runtimeAction; runtimeAction.processInstance = null; } @@ -449,8 +413,7 @@ /** * is the list of all runtime actions. */ - public List getRuntimeActions() - { + public List getRuntimeActions() { return runtimeActions; } @@ -459,19 +422,16 @@ /** * tells if this process instance is still active or not. */ - public boolean hasEnded() - { + public boolean hasEnded() { return (end != null); } /** * calculates if this process instance has still options to continue. */ - public boolean isTerminatedImplicitly() - { + public boolean isTerminatedImplicitly() { boolean isTerminatedImplicitly = true; - if (end == null) - { + if (end == null) { isTerminatedImplicitly = rootToken.isTerminatedImplicitly(); } return isTerminatedImplicitly; @@ -483,33 +443,28 @@ * @param tokenPath is a slash-separated name that specifies a token in the tree. * @return the specified token or null if the token is not found. */ - public Token findToken(String tokenPath) - { + public Token findToken(String tokenPath) { return (rootToken != null ? rootToken.findToken(tokenPath) : null); } /** * collects all instances for this process instance. */ - public List findAllTokens() - { + public List findAllTokens() { List tokens = new ArrayList(); tokens.add(rootToken); rootToken.collectChildrenRecursively(tokens); return tokens; } - void addCascadeProcessInstance(ProcessInstance cascadeProcessInstance) - { - if (cascadeProcessInstances == null) - { + void addCascadeProcessInstance(ProcessInstance cascadeProcessInstance) { + if (cascadeProcessInstances == null) { cascadeProcessInstances = new ArrayList(); } cascadeProcessInstances.add(cascadeProcessInstance); } - public Collection removeCascadeProcessInstances() - { + public Collection removeCascadeProcessInstances() { Collection removed = cascadeProcessInstances; cascadeProcessInstances = null; return removed; @@ -518,105 +473,86 @@ // 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); } - public String toString() - { - return "ProcessInstance" + (key != null ? '(' + key + ')' - : id != 0 ? "(" + id + ')' : '@' + Integer.toHexString(hashCode())); + public String toString() { + return "ProcessInstance" + + (key != null ? '(' + key + ')' : id != 0 ? "(" + id + ')' + : '@' + Integer.toHexString(hashCode())); } // getters and setters ////////////////////////////////////////////////////// - public long getId() - { + public long getId() { return id; } - public Token getRootToken() - { + public Token getRootToken() { return rootToken; } - public Date getStart() - { + public Date getStart() { return start; } - public Date getEnd() - { + public Date getEnd() { return end; } - public Map getInstances() - { + public Map getInstances() { return instances; } - public ProcessDefinition getProcessDefinition() - { + public ProcessDefinition getProcessDefinition() { return processDefinition; } - public Token getSuperProcessToken() - { + public Token getSuperProcessToken() { return superProcessToken; } - public void setSuperProcessToken(Token superProcessToken) - { + public void setSuperProcessToken(Token superProcessToken) { this.superProcessToken = superProcessToken; } - public boolean isSuspended() - { + public boolean isSuspended() { return isSuspended; } - public int getVersion() - { + public int getVersion() { return version; } - public void setVersion(int version) - { + public void setVersion(int version) { this.version = version; } - public void setEnd(Date end) - { + public void setEnd(Date end) { this.end = end; } - public void setProcessDefinition(ProcessDefinition processDefinition) - { + public void setProcessDefinition(ProcessDefinition processDefinition) { this.processDefinition = processDefinition; } - public void setRootToken(Token rootToken) - { + public void setRootToken(Token rootToken) { this.rootToken = rootToken; } - public void setStart(Date start) - { + public void setStart(Date start) { this.start = start; } /** a unique business key */ - public String getKey() - { + public String getKey() { return key; } /** set the unique business key */ - public void setKey(String key) - { + public void setKey(String key) { this.key = key; } - // private static Log log = LogFactory.getLog(ProcessInstance.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/Token.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/Token.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/exe/Token.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -33,6 +33,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.db.JobSession; @@ -55,11 +56,11 @@ /** * represents one path of execution and maintains a pointer to a node in the - * {@link org.jbpm.graph.def.ProcessDefinition}. Most common way to get a hold of the token objects is with - * {@link ProcessInstance#getRootToken()} or {@link org.jbpm.graph.exe.ProcessInstance#findToken(String)}. + * {@link org.jbpm.graph.def.ProcessDefinition}. Most common way to get a hold of the token objects + * is with {@link ProcessInstance#getRootToken()} or + * {@link org.jbpm.graph.exe.ProcessInstance#findToken(String)}. */ -public class Token implements Identifiable, Serializable -{ +public class Token implements Identifiable, Serializable { private static final long serialVersionUID = 1L; @@ -72,7 +73,7 @@ protected Date nodeEnter = null; protected ProcessInstance processInstance = null; protected Token parent = null; - protected Map<String,Token> children = null; + protected Map children = null; protected List comments = null; protected ProcessInstance subProcessInstance = null; protected int nextLogIndex = 0; @@ -85,15 +86,13 @@ // //////////////////// /////////////////////////////////////////////////////// - public Token() - { + public Token() { } /** * creates a root token. */ - public Token(ProcessInstance processInstance) - { + public Token(ProcessInstance processInstance) { this.start = Clock.getCurrentTime(); this.processInstance = processInstance; this.node = processInstance.getProcessDefinition().getStartState(); @@ -106,8 +105,7 @@ /** * creates a child token. */ - public Token(Token parent, String name) - { + public Token(Token parent, String name) { this.start = Clock.getCurrentTime(); this.processInstance = parent.getProcessInstance(); this.name = name; @@ -124,101 +122,97 @@ // operations // /////////////////////////////////////////////////////////////////////////// - void addChild(Token token) - { - if (children == null) - { - children = new HashMap<String,Token>(); + void addChild(Token token) { + if (children == null) { + children = new HashMap(); } children.put(token.getName(), token); } /** - * provides a signal to the token. this method activates this token and leaves the current state over the default - * transition. + * provides a signal to the token. this method activates this token and leaves the current state + * over the default transition. */ - public void signal() - { - if (node == null) - { - throw new JbpmException("token '" + this + "' can't be signalled cause it is currently not positioned in a node"); + public void signal() { + if (node == null) { + throw new JbpmException("token '" + + this + + "' can't be signalled cause it is currently not positioned in a node"); } - if (node.getDefaultLeavingTransition() == null) - { - throw new JbpmException("couldn't signal token '" + this + "' : node '" + node + "' doesn't have a default transition"); + if (node.getDefaultLeavingTransition() == null) { + throw new JbpmException("couldn't signal " + + this + + " : node " + + node + + " has no default transition"); } signal(node.getDefaultLeavingTransition(), new ExecutionContext(this)); } /** - * Provides a signal to the token. - * This leave the current state over the given transition name. + * Provides a signal to the token. This leave the current state over the given transition name. */ - public void signal(String transitionName) - { + public void signal(String transitionName) { if (node == null) - throw new JbpmException("token '" + this + "' can't be signalled cause it is currently not positioned in a node"); - + throw new JbpmException("token '" + + this + + "' can't be signalled cause it is currently not positioned in a node"); + Transition leavingTransition = node.getLeavingTransition(transitionName); - - if (leavingTransition == null) - { + + if (leavingTransition == null) { // Fall back to the name of the target node - for (Transition auxTrans : node.getLeavingTransitions()) - { - if (transitionName.equals(auxTrans.getTo().getName())) - { + for (Iterator i = node.getLeavingTransitions().iterator(); i.hasNext();) { + Transition auxTrans = (Transition) i.next(); + if (transitionName.equals(auxTrans.getTo().getName())) { leavingTransition = auxTrans; break; } } } - + if (leavingTransition == null) throw new JbpmException("transition '" + transitionName + "' does not exist on " + node); - + signal(leavingTransition, new ExecutionContext(this)); } /** * provides a signal to the token. this leave the current state over the given transition name. */ - public void signal(Transition transition) - { + public void signal(Transition transition) { signal(transition, new ExecutionContext(this)); } - void signal(ExecutionContext executionContext) - { + void signal(ExecutionContext executionContext) { signal(node.getDefaultLeavingTransition(), executionContext); } - void signal(Transition transition, ExecutionContext executionContext) - { - if (transition == null) - { - throw new JbpmException("couldn't signal without specifying a leaving transition : transition is null"); + void signal(Transition transition, ExecutionContext executionContext) { + if (transition == null) { + throw new JbpmException( + "couldn't signal without specifying a leaving transition : transition is null"); } - if (executionContext == null) - { - throw new JbpmException("couldn't signal without an execution context: executionContext is null"); + if (executionContext == null) { + throw new JbpmException( + "couldn't signal without an execution context: executionContext is null"); } - if (isSuspended) - { + if (isSuspended) { throw new JbpmException("can't signal token '" + name + "' (" + id + "): it is suspended"); } - if (isLocked()) - { + if (isLocked()) { throw new JbpmException("this token is locked by " + lock); } - if (hasEnded()) - { - throw new JbpmException("Token '" + name + "' (" + id + ") is already ended and cannot be signaled"); + if (hasEnded()) { + throw new JbpmException("Token '" + + name + + "' (" + + id + + ") is already ended and cannot be signaled"); } startCompositeLog(new SignalLog(transition)); - try - { + try { // fire the event before-signal Node signalNode = node; signalNode.fireEvent(Event.EVENTTYPE_BEFORE_SIGNAL, executionContext); @@ -233,80 +227,71 @@ signalNode.fireEvent(Event.EVENTTYPE_AFTER_SIGNAL, executionContext); } - finally - { + finally { endCompositeLog(); } } /** - * a set of all the leaving transitions on the current node for which the condition expression resolves to true. + * a set of all the leaving transitions on the current node for which the condition expression + * resolves to true. */ - public Set getAvailableTransitions() - { + public Set getAvailableTransitions() { Set availableTransitions = new HashSet(); - if (node != null) - { + if (node != null) { addAvailableTransitionsOfNode(node, availableTransitions); } return availableTransitions; } /** - * adds available transitions of that node to the Set and after that calls itself recursivly for the SuperSate of the - * Node if it has a super state + * adds available transitions of that node to the Set and after that calls itself recursivly for + * the SuperSate of the Node if it has a super state */ - private void addAvailableTransitionsOfNode(Node currentNode, Set availableTransitions) - { + private void addAvailableTransitionsOfNode(Node currentNode, Set availableTransitions) { List leavingTransitions = currentNode.getLeavingTransitions(); - if (leavingTransitions != null) - { + if (leavingTransitions != null) { Iterator iter = leavingTransitions.iterator(); - while (iter.hasNext()) - { - Transition transition = (Transition)iter.next(); + while (iter.hasNext()) { + Transition transition = (Transition) iter.next(); String conditionExpression = transition.getCondition(); - if (conditionExpression != null) - { - Object result = JbpmExpressionEvaluator.evaluate(conditionExpression, new ExecutionContext(this)); - if ((result instanceof Boolean) && (((Boolean)result).booleanValue())) - { + if (conditionExpression != null) { + Object result = JbpmExpressionEvaluator.evaluate(conditionExpression, + new ExecutionContext(this)); + if ((result instanceof Boolean) && (((Boolean) result).booleanValue())) { availableTransitions.add(transition); } } - else - { + else { availableTransitions.add(transition); } } } - if (currentNode.getSuperState() != null) - { + if (currentNode.getSuperState() != null) { addAvailableTransitionsOfNode(currentNode.getSuperState(), availableTransitions); } } /** - * ends this token and all of its children (if any). this is the last active (=not-ended) child of a parent token, the - * parent token will be ended as well and that verification will continue to propagate. + * ends this token and all of its children (if any). this is the last active (=not-ended) child of + * a parent token, the parent token will be ended as well and that verification will continue to + * propagate. */ - public void end() - { + public void end() { end(true); } /** * ends this token with optional parent ending verification. * - * @param verifyParentTermination specifies if the parent token should be checked for termination. if - * verifyParentTermination is set to true and this is the last non-ended child of a parent token, the parent - * token will be ended as well and the verification will continue to propagate. + * @param verifyParentTermination specifies if the parent token should be checked for termination. + * if verifyParentTermination is set to true and this is the last non-ended child of a + * parent token, the parent token will be ended as well and the verification will + * continue to propagate. */ - public void end(boolean verifyParentTermination) - { + public void end(boolean verifyParentTermination) { // if not already ended - if (end == null) - { + if (end == null) { // ended tokens cannot reactivate parents isAbleToReactivateParent = false; @@ -316,40 +301,34 @@ this.end = Clock.getCurrentTime(); // end all this token's children - if (children != null) - { + if (children != null) { Iterator iter = children.values().iterator(); - while (iter.hasNext()) - { - Token child = (Token)iter.next(); - if (!child.hasEnded()) - { + while (iter.hasNext()) { + Token child = (Token) iter.next(); + if (!child.hasEnded()) { child.end(); } } } - if (subProcessInstance != null) - { + if (subProcessInstance != null) { subProcessInstance.end(); } // only log the end of child-tokens. the process instance logs replace the root token logs. - if (parent != null) - { + if (parent != null) { // add a log parent.addLog(new TokenEndLog(this)); } // if there are tasks associated to this token, remove signaling capabilities - TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() : null); - if (taskMgmtInstance != null) - { + TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() + : null); + if (taskMgmtInstance != null) { taskMgmtInstance.removeSignalling(this); } - if (verifyParentTermination) - { + if (verifyParentTermination) { // if this is the last active token of the parent, // the parent needs to be ended as well notifyParentOfTokenEnd(); @@ -359,21 +338,17 @@ // comments ///////////////////////////////////////////////////////////////// - public void addComment(String message) - { + public void addComment(String message) { addComment(new Comment(message)); } - public void addComment(Comment comment) - { - if (comments == null) - comments = new ArrayList(); + public void addComment(Comment comment) { + if (comments == null) comments = new ArrayList(); comments.add(comment); comment.setToken(this); } - public List getComments() - { + public List getComments() { return comments; } @@ -382,17 +357,13 @@ /** * notifies a parent that one of its nodeMap has ended. */ - void notifyParentOfTokenEnd() - { - if (isRoot()) - { + void notifyParentOfTokenEnd() { + if (isRoot()) { processInstance.end(); } - else - { + else { - if (!parent.hasActiveChildren()) - { + if (!parent.hasActiveChildren()) { parent.end(); } } @@ -401,19 +372,15 @@ /** * tells if this token has child tokens that have not yet ended. */ - public boolean hasActiveChildren() - { + public boolean hasActiveChildren() { boolean foundActiveChildToken = false; // try and find at least one child token that is // still active (= not ended) - if (children != null) - { + if (children != null) { Iterator iter = children.values().iterator(); - while ((iter.hasNext()) && (!foundActiveChildToken)) - { - Token child = (Token)iter.next(); - if (!child.hasEnded()) - { + while ((iter.hasNext()) && (!foundActiveChildToken)) { + Token child = (Token) iter.next(); + if (!child.hasEnded()) { foundActiveChildToken = true; } } @@ -426,25 +393,21 @@ /** * convenience method for adding a process log. */ - public void addLog(ProcessLog processLog) - { - LoggingInstance li = (LoggingInstance)processInstance.getInstance(LoggingInstance.class); - if (li != null) - { + public void addLog(ProcessLog processLog) { + LoggingInstance li = (LoggingInstance) processInstance.getInstance(LoggingInstance.class); + if (li != null) { processLog.setToken(this); li.addLog(processLog); } } /** - * convenience method for starting a composite log. When you add composite logs, make sure you put the - * {@link #endCompositeLog()} in a finally block. + * convenience method for starting a composite log. When you add composite logs, make sure you put + * the {@link #endCompositeLog()} in a finally block. */ - public void startCompositeLog(CompositeLog compositeLog) - { - LoggingInstance li = (LoggingInstance)processInstance.getInstance(LoggingInstance.class); - if (li != null) - { + public void startCompositeLog(CompositeLog compositeLog) { + LoggingInstance li = (LoggingInstance) processInstance.getInstance(LoggingInstance.class); + if (li != null) { compositeLog.setToken(this); li.startCompositeLog(compositeLog); } @@ -453,156 +416,122 @@ /** * convenience method for ending a composite log. Make sure you put this in a finally block. */ - public void endCompositeLog() - { - LoggingInstance li = (LoggingInstance)processInstance.getInstance(LoggingInstance.class); - if (li != null) - { + public void endCompositeLog() { + LoggingInstance li = (LoggingInstance) processInstance.getInstance(LoggingInstance.class); + if (li != null) { li.endCompositeLog(); } } // various information extraction methods /////////////////////////////////// - public String toString() - { + public String toString() { return "Token(" + getFullName() + ')'; } - public boolean hasEnded() - { + public boolean hasEnded() { return (end != null); } - public boolean isRoot() - { + public boolean isRoot() { return (parent == null); } - public boolean hasParent() - { + public boolean hasParent() { return (parent != null); } - public boolean hasChild(String name) - { + public boolean hasChild(String name) { return (children != null ? children.containsKey(name) : false); } - public Token getChild(String name) - { + public Token getChild(String name) { Token child = null; - if (children != null) - { - child = (Token)children.get(name); + if (children != null) { + child = (Token) children.get(name); } return child; } - public String getFullName() - { - if (parent == null) - return "/"; - if (parent.getParent() == null) - return "/" + name; + public String getFullName() { + if (parent == null) return "/"; + if (parent.getParent() == null) return "/" + name; return parent.getFullName() + "/" + name; } - public List getChildrenAtNode(Node aNode) - { + public List getChildrenAtNode(Node aNode) { List foundChildren = new ArrayList(); getChildrenAtNode(aNode, foundChildren); return foundChildren; } - void getChildrenAtNode(Node aNode, List foundTokens) - { - if (aNode.equals(node)) - { + void getChildrenAtNode(Node aNode, List foundTokens) { + if (aNode.equals(node)) { foundTokens.add(this); } - else if (children != null && !children.isEmpty()) - { - for (Iterator it = children.values().iterator(); it.hasNext();) - { - Token aChild = (Token)it.next(); + else if (children != null && !children.isEmpty()) { + for (Iterator it = children.values().iterator(); it.hasNext();) { + Token aChild = (Token) it.next(); aChild.getChildrenAtNode(aNode, foundTokens); } } } - public void collectChildrenRecursively(List tokens) - { - if (children != null) - { + public void collectChildrenRecursively(List tokens) { + if (children != null) { Iterator iter = children.values().iterator(); - while (iter.hasNext()) - { - Token child = (Token)iter.next(); + while (iter.hasNext()) { + Token child = (Token) iter.next(); tokens.add(child); child.collectChildrenRecursively(tokens); } } } - public Token findToken(String relativeTokenPath) - { - if (relativeTokenPath == null) - return null; + public Token findToken(String relativeTokenPath) { + if (relativeTokenPath == null) return null; String path = relativeTokenPath.trim(); - if (("".equals(path)) || (".".equals(path))) - { + if (("".equals(path)) || (".".equals(path))) { return this; } - if ("..".equals(path)) - { + if ("..".equals(path)) { return parent; } - if (path.startsWith("/")) - { + if (path.startsWith("/")) { Token root = processInstance.getRootToken(); return root.findToken(path.substring(1)); } - if (path.startsWith("./")) - { + if (path.startsWith("./")) { return findToken(path.substring(2)); } - if (path.startsWith("../")) - { - if (parent != null) - { + if (path.startsWith("../")) { + if (parent != null) { return parent.findToken(path.substring(3)); } return null; } int slashIndex = path.indexOf('/'); - if (slashIndex == -1) - { - return (Token)(children != null ? children.get(path) : null); + if (slashIndex == -1) { + return (Token) (children != null ? children.get(path) : null); } Token token = null; String name = path.substring(0, slashIndex); - token = (Token)children.get(name); - if (token != null) - { + token = (Token) children.get(name); + if (token != null) { return token.findToken(path.substring(slashIndex + 1)); } return null; } - public Map getActiveChildren() - { + public Map getActiveChildren() { Map activeChildren = new HashMap(); - if (children != null) - { + if (children != null) { Iterator iter = children.entrySet().iterator(); - while (iter.hasNext()) - { - Map.Entry entry = (Map.Entry)iter.next(); - Token child = (Token)entry.getValue(); - if (!child.hasEnded()) - { - String childName = (String)entry.getKey(); + while (iter.hasNext()) { + Map.Entry entry = (Map.Entry) iter.next(); + Token child = (Token) entry.getValue(); + if (!child.hasEnded()) { + String childName = (String) entry.getKey(); activeChildren.put(childName, child); } } @@ -610,38 +539,30 @@ return activeChildren; } - public void checkImplicitTermination() - { - if (isTerminationImplicit && node.hasNoLeavingTransitions()) - { + public void checkImplicitTermination() { + if (isTerminationImplicit && node.hasNoLeavingTransitions()) { end(); - if (processInstance.isTerminatedImplicitly()) - { + if (processInstance.isTerminatedImplicitly()) { processInstance.end(); } } } - public boolean isTerminatedImplicitly() - { - if (end != null) - return true; + public boolean isTerminatedImplicitly() { + if (end != null) return true; Map leavingTransitions = node.getLeavingTransitionsMap(); - if ((leavingTransitions != null) && (leavingTransitions.size() > 0)) - { + if ((leavingTransitions != null) && (leavingTransitions.size() > 0)) { // ok: found a non-terminated token return false; } // loop over all active child tokens Iterator iter = getActiveChildren().values().iterator(); - while (iter.hasNext()) - { - Token child = (Token)iter.next(); - if (!child.isTerminatedImplicitly()) - { + while (iter.hasNext()) { + Token child = (Token) iter.next(); + if (!child.isTerminatedImplicitly()) { return false; } } @@ -649,48 +570,41 @@ return true; } - public int nextLogIndex() - { + public int nextLogIndex() { return nextLogIndex++; } /** * suspends a process execution. */ - public void suspend() - { + public void suspend() { isSuspended = true; suspendJobs(); suspendTaskInstances(); // propagate to child tokens - if (children != null) - { + if (children != null) { Iterator iter = children.values().iterator(); - while (iter.hasNext()) - { - Token child = (Token)iter.next(); + while (iter.hasNext()) { + Token child = (Token) iter.next(); child.suspend(); } } } - void suspendJobs() - { + void suspendJobs() { JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext(); JobSession jobSession = (jbpmContext != null ? jbpmContext.getJobSession() : null); - if (jobSession != null) - { + if (jobSession != null) { jobSession.suspendJobs(this); } } - void suspendTaskInstances() - { - TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() : null); - if (taskMgmtInstance != null) - { + void suspendTaskInstances() { + TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() + : null); + if (taskMgmtInstance != null) { taskMgmtInstance.suspend(this); } } @@ -698,40 +612,34 @@ /** * resumes a process execution. */ - public void resume() - { + public void resume() { isSuspended = false; resumeJobs(); resumeTaskInstances(); // propagate to child tokens - if (children != null) - { + if (children != null) { Iterator iter = children.values().iterator(); - while (iter.hasNext()) - { - Token child = (Token)iter.next(); + while (iter.hasNext()) { + Token child = (Token) iter.next(); child.resume(); } } } - void resumeJobs() - { + void resumeJobs() { JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext(); JobSession jobSession = (jbpmContext != null ? jbpmContext.getJobSession() : null); - if (jobSession != null) - { + if (jobSession != null) { jobSession.resumeJobs(this); } } - void resumeTaskInstances() - { - TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() : null); - if (taskMgmtInstance != null) - { + void resumeTaskInstances() { + TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance() + : null); + if (taskMgmtInstance != null) { taskMgmtInstance.resume(this); } } @@ -739,13 +647,11 @@ // 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); } - public ProcessInstance createSubProcessInstance(ProcessDefinition subProcessDefinition) - { + public ProcessInstance createSubProcessInstance(ProcessDefinition subProcessDefinition) { // create the new sub process instance subProcessInstance = new ProcessInstance(subProcessDefinition); // bind the subprocess to the super-process-token @@ -757,20 +663,24 @@ } /** - * locks a process instance for further execution. A locked token cannot continue execution. This is a non-persistent - * operation. This is used to prevent tokens being propagated during the execution of actions. + * locks a process instance for further execution. A locked token cannot continue execution. This + * is a non-persistent operation. This is used to prevent tokens being propagated during the + * execution of actions. * * @see #unlock(String) */ - public void lock(String lockOwnerId) - { - if (lockOwnerId == null) - { + public void lock(String lockOwnerId) { + if (lockOwnerId == null) { throw new JbpmException("can't lock with null value for the lockOwnerId"); } - if ((lock != null) && (!lock.equals(lockOwnerId))) - { - throw new JbpmException("token '" + id + "' can't be locked by '" + lockOwnerId + "' cause it's already locked by '" + lock + "'"); + if ((lock != null) && (!lock.equals(lockOwnerId))) { + throw new JbpmException("token '" + + id + + "' can't be locked by '" + + lockOwnerId + + "' cause it's already locked by '" + + lock + + "'"); } log.debug("token[" + id + "] is locked by " + lockOwnerId); lock = lockOwnerId; @@ -779,151 +689,131 @@ /** * @see #lock(String) */ - public void unlock(String lockOwnerId) - { - if (lock == null) - { - log.warn("lock owner '" + lockOwnerId + "' tries to unlock token '" + id + "' which is not locked"); + public void unlock(String lockOwnerId) { + if (lock == null) { + log.warn("lock owner '" + + lockOwnerId + + "' tries to unlock token '" + + id + + "' which is not locked"); } - else if (!lock.equals(lockOwnerId)) - { - throw new JbpmException("'" + lockOwnerId + "' can't unlock token '" + id + "' because it was already locked by '" + lock + "'"); + else if (!lock.equals(lockOwnerId)) { + throw new JbpmException("'" + + lockOwnerId + + "' can't unlock token '" + + id + + "' because it was already locked by '" + + lock + + "'"); } log.debug("token[" + id + "] is unlocked by " + lockOwnerId); lock = null; } /** - * force unlocking the token, even if the owner is not known. In some - * use cases (e.g. in the jbpm esb integration) the lock is persistent, - * so a state can be reached where the client needs a possibility to force - * unlock of a token without knowing the owner. - * - * See https://jira.jboss.org/jira/browse/JBPM-1888 + * force unlocking the token, even if the owner is not known. In some use cases (e.g. in the jbpm + * esb integration) the lock is persistent, so a state can be reached where the client needs a + * possibility to force unlock of a token without knowing the owner. See + * https://jira.jboss.org/jira/browse/JBPM-1888 */ - public void foreUnlock() - { - if (lock == null) - { + public void foreUnlock() { + if (lock == null) { log.warn("Unlock of token '" + id + "' forced, but it is not locked"); } log.debug("Foce unlock of token[" + id + "] which was locked by " + lock); lock = null; } - + /** - * return the current lock owner of the token - * - * See https://jira.jboss.org/jira/browse/JBPM-1888 + * return the current lock owner of the token See https://jira.jboss.org/jira/browse/JBPM-1888 */ public String getLockOwner() { - return lock; + return lock; } - - public boolean isLocked() - { + + public boolean isLocked() { return lock != null; } // getters and setters ////////////////////////////////////////////////////// - public long getId() - { + public long getId() { return id; } - public Date getStart() - { + public Date getStart() { return start; } - public Date getEnd() - { + public Date getEnd() { return end; } - public String getName() - { + public String getName() { return name; } - public ProcessInstance getProcessInstance() - { + public ProcessInstance getProcessInstance() { return processInstance; } - public Map<String,Token> getChildren() - { + public Map getChildren() { return children; } - public Node getNode() - { + public Node getNode() { return node; } - public void setNode(Node node) - { + public void setNode(Node node) { this.node = node; } - public Token getParent() - { + public Token getParent() { return parent; } - public void setParent(Token parent) - { + public void setParent(Token parent) { this.parent = parent; } - public void setProcessInstance(ProcessInstance processInstance) - { + public void setProcessInstance(ProcessInstance processInstance) { this.processInstance = processInstance; } - public ProcessInstance getSubProcessInstance() - { + public ProcessInstance getSubProcessInstance() { return subProcessInstance; } - public Date getNodeEnter() - { + public Date getNodeEnter() { return nodeEnter; } - public void setNodeEnter(Date nodeEnter) - { + public void setNodeEnter(Date nodeEnter) { this.nodeEnter = nodeEnter; } - public boolean isAbleToReactivateParent() - { + public boolean isAbleToReactivateParent() { return isAbleToReactivateParent; } - public void setAbleToReactivateParent(boolean isAbleToReactivateParent) - { + public void setAbleToReactivateParent(boolean isAbleToReactivateParent) { this.isAbleToReactivateParent = isAbleToReactivateParent; } - public boolean isTerminationImplicit() - { + public boolean isTerminationImplicit() { return isTerminationImplicit; } - public void setTerminationImplicit(boolean isTerminationImplicit) - { + public void setTerminationImplicit(boolean isTerminationImplicit) { this.isTerminationImplicit = isTerminationImplicit; } - public boolean isSuspended() - { + public boolean isSuspended() { return isSuspended; } - public void setSubProcessInstance(ProcessInstance subProcessInstance) - { + public void setSubProcessInstance(ProcessInstance subProcessInstance) { this.subProcessInstance = subProcessInstance; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Decision.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Decision.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Decision.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -27,6 +27,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.dom4j.Element; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmException; import org.jbpm.graph.def.Node; @@ -36,13 +37,12 @@ import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator; import org.jbpm.jpdl.xml.JpdlXmlReader; import org.jbpm.jpdl.xml.Parsable; -import org.jbpm.util.ClassLoaderUtil; /** * decision node. */ -public class Decision extends Node implements Parsable -{ +public class Decision extends Node implements Parsable { + static final String NEWLINE = System.getProperty("line.separator"); static final String DECISION_CONDITION_RESULT = "decision_condition_result"; static final long serialVersionUID = 1L; @@ -51,124 +51,113 @@ Delegation decisionDelegation = null; String decisionExpression = null; - public Decision() - { + public Decision() { } - public Decision(String name) - { + public Decision(String name) { super(name); } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.Decision; } - public void read(Element decisionElement, JpdlXmlReader jpdlReader) - { + public void read(Element decisionElement, JpdlXmlReader jpdlReader) { String expression = decisionElement.attributeValue("expression"); Element decisionHandlerElement = decisionElement.element("handler"); - if (expression != null) - { + if (expression != null) { decisionExpression = expression; } - else if (decisionHandlerElement != null) - { + else if (decisionHandlerElement != null) { decisionDelegation = new Delegation(); decisionDelegation.read(decisionHandlerElement, jpdlReader); } } - public void execute(ExecutionContext executionContext) - { + public void execute(ExecutionContext executionContext) { Transition transition = null; ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader(); - try - { + try { // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448) - Thread.currentThread().setContextClassLoader(JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); + Thread.currentThread().setContextClassLoader( + JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); - try - { - if (decisionDelegation != null) - { - DecisionHandler decisionHandler = (DecisionHandler)decisionDelegation.getInstance(); + try { + if (decisionDelegation != null) { + DecisionHandler decisionHandler = (DecisionHandler) decisionDelegation.getInstance(); if (decisionHandler == null) - decisionHandler = (DecisionHandler)decisionDelegation.instantiate(); + decisionHandler = (DecisionHandler) decisionDelegation.instantiate(); String transitionName = decisionHandler.decide(executionContext); transition = getLeavingTransition(transitionName); - if (transition == null) - { - throw new JbpmException("decision '" + name + "' selected non existing transition '" + transitionName + "'"); + if (transition == null) { + throw new JbpmException("decision '" + + name + + "' selected non existing transition '" + + transitionName + + "'"); } } - else if (decisionExpression != null) - { + else if (decisionExpression != null) { Object result = JbpmExpressionEvaluator.evaluate(decisionExpression, executionContext); - if (result == null) - { - throw new JbpmException("decision expression '" + decisionExpression + "' returned null"); + if (result == null) { + throw new JbpmException("decision expression '" + + decisionExpression + + "' returned null"); } String transitionName = result.toString(); transition = getLeavingTransition(transitionName); - if (transition == null) - { - throw new JbpmException("decision '" + name + "' selected non existing transition '" + transitionName + "'"); + if (transition == null) { + throw new JbpmException("decision '" + + name + + "' selected non existing transition '" + + transitionName + + "'"); } } - else if (decisionConditions != null && !decisionConditions.isEmpty()) - { + else if (decisionConditions != null && !decisionConditions.isEmpty()) { // backwards compatible mode based on separate DecisionCondition's Iterator iter = decisionConditions.iterator(); - while (iter.hasNext() && (transition == null)) - { - DecisionCondition decisionCondition = (DecisionCondition)iter.next(); - Object result = JbpmExpressionEvaluator.evaluate(decisionCondition.getExpression(), executionContext); - if (Boolean.TRUE.equals(result)) - { + while (iter.hasNext() && (transition == null)) { + DecisionCondition decisionCondition = (DecisionCondition) iter.next(); + Object result = JbpmExpressionEvaluator.evaluate(decisionCondition.getExpression(), + executionContext); + if (Boolean.TRUE.equals(result)) { String transitionName = decisionCondition.getTransitionName(); transition = getLeavingTransition(transitionName); - if (transition != null) - { + if (transition != null) { transition.removeConditionEnforcement(); } } } } - else - { + else { // new mode based on conditions in the transition itself Iterator iter = leavingTransitions.iterator(); - while (iter.hasNext() && (transition == null)) - { - Transition candidate = (Transition)iter.next(); + while (iter.hasNext() && (transition == null)) { + Transition candidate = (Transition) iter.next(); String conditionExpression = candidate.getCondition(); - if (conditionExpression != null) - { - Object result = JbpmExpressionEvaluator.evaluate(conditionExpression, executionContext); - if (Boolean.TRUE.equals(result)) - { + if (conditionExpression != null) { + Object result = JbpmExpressionEvaluator.evaluate(conditionExpression, + executionContext); + if (Boolean.TRUE.equals(result)) { transition = candidate; } } } } + if (transition == null) transition = getDefaultLeavingTransition(); + if (transition == null) - transition = getDefaultLeavingTransition(); - - if (transition == null) throw new IllegalStateException("decision cannot select transition: " + this); - + log.debug("decision didn't select transition, taking default " + transition); // since the decision node evaluates condition expressions, the @@ -180,27 +169,23 @@ transition.removeConditionEnforcement(); } - catch (Exception exception) - { + catch (Exception exception) { raiseException(exception, executionContext); } } - finally - { + finally { Thread.currentThread().setContextClassLoader(surroundingClassLoader); } log.debug("decision " + name + " is taking '" + transition + "'"); executionContext.leaveNode(transition); } - public List getDecisionConditions() - { + public List getDecisionConditions() { return decisionConditions; } - public void setDecisionDelegation(Delegation decisionDelegation) - { + public void setDecisionDelegation(Delegation decisionDelegation) { this.decisionDelegation = decisionDelegation; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/EndState.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/EndState.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/EndState.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -22,22 +22,24 @@ package org.jbpm.graph.node; import org.dom4j.Element; + import org.jbpm.graph.def.Event; import org.jbpm.graph.def.Node; import org.jbpm.graph.def.Transition; -import org.jbpm.graph.exe.*; +import org.jbpm.graph.exe.ExecutionContext; import org.jbpm.jpdl.xml.JpdlXmlReader; public class EndState extends Node { private static final long serialVersionUID = 1L; - + String endCompleteProcess = null; public EndState() { } - - public static final String[] supportedEventTypes = new String[]{Event.EVENTTYPE_NODE_ENTER}; + + public static final String[] supportedEventTypes = new String[] { Event.EVENTTYPE_NODE_ENTER }; + public String[] getSupportedEventTypes() { return supportedEventTypes; } @@ -45,10 +47,8 @@ public EndState(String name) { super(name); } - - @Override - public NodeType getNodeType() - { + + public NodeType getNodeType() { return NodeType.EndState; } @@ -57,15 +57,14 @@ } public void execute(ExecutionContext executionContext) { - if ( (endCompleteProcess!=null) - && (endCompleteProcess.equalsIgnoreCase("true")) - ) { + if ((endCompleteProcess != null) && (endCompleteProcess.equalsIgnoreCase("true"))) { executionContext.getProcessInstance().end(); - } else { + } + else { executionContext.getToken().end(); } } - + public Transition addLeavingTransition(Transition t) { throw new UnsupportedOperationException("can't add a leaving transition to an end-state"); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Fork.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Fork.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Fork.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,6 +30,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.dom4j.Element; + import org.jbpm.JbpmException; import org.jbpm.graph.action.Script; import org.jbpm.graph.def.Node; @@ -40,23 +41,18 @@ /** * specifies configurable fork behaviour. - * - * <p>if this fork behaviour is not sufficient for your needs, consider - * writing your own custom TokenHandler. + * <p> + * if this fork behaviour is not sufficient for your needs, consider writing your own custom + * TokenHandler. * </p> - * - * <p>this forkhandler can be configured in 3 ways : + * <p> + * this forkhandler can be configured in 3 ways : * <ul> - * <li>without configuration : in that case the fork will launch one - * new sub-token over each of the leaving tranisions of the fork - * node. - * </li> - * <li>a script : can be used to calculate a collection of transition - * names at runtime. if a script is configured, the script must have - * exactly one variable with 'write' access. that variable - * should be assigned a java.util.Collection in the script - * expression. - * </li> + * <li>without configuration : in that case the fork will launch one new sub-token over each of the + * leaving tranisions of the fork node.</li> + * <li>a script : can be used to calculate a collection of transition names at runtime. if a script + * is configured, the script must have exactly one variable with 'write' access. that variable + * should be assigned a java.util.Collection in the script expression.</li> * </ul> * </p> */ @@ -76,15 +72,13 @@ super(name); } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.Fork; } public void read(Element forkElement, JpdlXmlReader jpdlReader) { Element scriptElement = forkElement.element("script"); - if (scriptElement!=null) { + if (scriptElement != null) { log.warn("KNOWN LIMITATION: the script in a fork is not persisted. script in fork might be removed in later versions of jPDL"); script = new Script(); script.read(scriptElement, jpdlReader); @@ -93,35 +87,40 @@ public void execute(ExecutionContext executionContext) { Token token = executionContext.getToken(); - + // phase one: collect all the transitionNames - Collection transitionNames = null; + Collection transitionNames = null; List forkedTokens = new ArrayList(); // by default, the fork spawns a token for each leaving transition - if (script==null) { + if (script == null) { transitionNames = getLeavingTransitionsMap().keySet(); - } else { // a script is specified + } + else { // a script is specified // if a script is specified, use that script to calculate the set // of leaving transitions to be used for forking tokens. Map outputMap = null; try { outputMap = script.eval(token); - } catch (Exception e) { + } + catch (Exception e) { this.raiseException(e, executionContext); } - if (outputMap.size()==1) { + if (outputMap.size() == 1) { Object result = outputMap.values().iterator().next(); if (result instanceof Collection) { transitionNames = (Collection) result; } } - if (transitionNames==null) { - throw new JbpmException("script for fork '"+name+"' should produce one collection (in one writable variable): "+transitionNames); + if (transitionNames == null) { + throw new JbpmException("script for fork '" + + name + + "' should produce one collection (in one writable variable): " + + transitionNames); } } - + // TODO add some way of blocking the current token here and disable that blocking when the join reactivates this token // Then an exception can be thrown by in case someone tries to signal a token that is waiting in a fork. // Suspend and resume can NOT be used for this since that will also suspend any related timers, tasks and messages... @@ -137,14 +136,15 @@ // phase three: launch child tokens from the fork over the given transitions iter = forkedTokens.iterator(); - while( iter.hasNext() ) { + while (iter.hasNext()) { ForkedToken forkedToken = (ForkedToken) iter.next(); Token childToken = forkedToken.token; String leavingTransitionName = forkedToken.leavingTransitionName; ExecutionContext childExecutionContext = new ExecutionContext(childToken); - if (leavingTransitionName!=null) { + if (leavingTransitionName != null) { leave(childExecutionContext, leavingTransitionName); - } else { + } + else { leave(childExecutionContext); } } @@ -157,25 +157,27 @@ // create a forked token ForkedToken forkedToken = null; forkedToken = new ForkedToken(childToken, transitionName); - + return forkedToken; } protected String getTokenName(Token parent, String transitionName) { String tokenName = null; - if ( transitionName != null ) { - if ( ! parent.hasChild( transitionName ) ) { + if (transitionName != null) { + if (!parent.hasChild(transitionName)) { tokenName = transitionName; - } else { + } + else { int i = 2; - tokenName = transitionName + Integer.toString( i ); - while ( parent.hasChild( tokenName ) ) { + tokenName = transitionName + Integer.toString(i); + while (parent.hasChild(tokenName)) { i++; - tokenName = transitionName + Integer.toString( i ); + tokenName = transitionName + Integer.toString(i); } } - } else { // no transition name - int size = ( parent.getChildren()!=null ? parent.getChildren().size()+1 : 1 ); + } + else { // no transition name + int size = (parent.getChildren() != null ? parent.getChildren().size() + 1 : 1); tokenName = Integer.toString(size); } return tokenName; @@ -184,18 +186,21 @@ public Script getScript() { return script; } + public void setScript(Script script) { this.script = script; } - + static class ForkedToken { + Token token = null; String leavingTransitionName = null; + public ForkedToken(Token token, String leavingTransitionName) { this.token = token; this.leavingTransitionName = leavingTransitionName; } } - + private static Log log = LogFactory.getLog(Fork.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Join.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Join.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/Join.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,6 +29,7 @@ import org.dom4j.Element; import org.hibernate.LockMode; import org.hibernate.Session; + import org.jbpm.JbpmContext; import org.jbpm.graph.action.Script; import org.jbpm.graph.def.Node; @@ -40,17 +41,16 @@ public class Join extends Node implements Parsable { private static final long serialVersionUID = 1L; - - /** - * specifies what type of hibernate lock should be acquired. - * null value defaults to LockMode.UPGRADE - */ + + /** + * specifies what type of hibernate lock should be acquired. null value defaults to + * LockMode.UPGRADE + */ String parentLockMode; /** - * specifies if this join is a discriminator. - * a descriminator reactivates the parent when the first - * concurrent token enters the join. + * specifies if this join is a discriminator. a descriminator reactivates the parent when the + * first concurrent token enters the join. */ boolean isDiscriminator = false; @@ -63,12 +63,11 @@ * a script that calculates concurrent tokens at runtime. */ Script script = null; - + /** * reactivate the parent if the n-th token arrives in the join. */ int nOutOfM = -1; - public Join() { } @@ -77,9 +76,7 @@ super(name); } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.Join; } @@ -98,28 +95,28 @@ public void execute(ExecutionContext executionContext) { Token token = executionContext.getToken(); - + boolean isAbleToReactivateParent = token.isAbleToReactivateParent(); - + if (!token.hasEnded()) { token.end(false); } - + // if this token is not able to reactivate the parent, // we don't need to check anything - if ( isAbleToReactivateParent ) { + if (isAbleToReactivateParent) { // the token arrived in the join and can only reactivate // the parent once token.setAbleToReactivateParent(false); Token parentToken = token.getParent(); - - if ( parentToken != null ) { - + + if (parentToken != null) { + JbpmContext jbpmContext = executionContext.getJbpmContext(); - Session session = (jbpmContext!=null ? jbpmContext.getSession() : null); - if (session!=null) { + Session session = (jbpmContext != null ? jbpmContext.getSession() : null); + if (session != null) { // obtain update lock by default (LockMode.UPGRADE) LockMode lockMode = parentLockMode != null ? LockMode.parse(parentLockMode) : LockMode.UPGRADE; @@ -131,61 +128,68 @@ boolean reactivateParent = true; // if this is a discriminator - if ( isDiscriminator ) { + if (isDiscriminator) { // reactivate the parent when the first token arrives in the join. // this must be the first token arriving, otherwise isAbleToReactivateParent() // should have been false above. reactivateParent = true; - // if a fixed set of tokenNames is specified at design time... - } else if ( tokenNames != null ) { + // if a fixed set of tokenNames is specified at design time... + } + else if (tokenNames != null) { // check reactivation on the basis of those tokenNames - reactivateParent = mustParentBeReactivated(parentToken, tokenNames.iterator() ); + reactivateParent = mustParentBeReactivated(parentToken, tokenNames.iterator()); - // if a script is specified - } else if ( script != null ) { + // if a script is specified + } + else if (script != null) { // check if the script returns a collection or a boolean Object result = null; try { - result = script.eval( token ); - } catch (Exception e) { + result = script.eval(token); + } + catch (Exception e) { this.raiseException(e, executionContext); } // if the result is a collection - if ( result instanceof Collection ) { + if (result instanceof Collection) { // it must be a collection of tokenNames Collection runtimeTokenNames = (Collection) result; - reactivateParent = mustParentBeReactivated(parentToken, runtimeTokenNames.iterator() ); + reactivateParent = mustParentBeReactivated(parentToken, runtimeTokenNames.iterator()); - - // if it's a boolean... - } else if ( result instanceof Boolean ) { + // if it's a boolean... + } + else if (result instanceof Boolean) { // the boolean specifies if the parent needs to be reactivated - reactivateParent = ((Boolean)result).booleanValue(); + reactivateParent = ((Boolean) result).booleanValue(); } - // if a nOutOfM is specified - } else if ( nOutOfM != -1 ) { + // if a nOutOfM is specified + } + else if (nOutOfM != -1) { int n = 0; // wheck how many tokens already arrived in the join Iterator iter = parentToken.getChildren().values().iterator(); - while ( iter.hasNext() ) { - Token concurrentToken = (Token)iter.next(); + while (iter.hasNext()) { + Token concurrentToken = (Token) iter.next(); if (this.equals(concurrentToken.getNode())) { n++; } } - if ( n < nOutOfM ) { + if (n < nOutOfM) { reactivateParent = false; } - - // if no configuration is specified.. - } else { + + // if no configuration is specified.. + } + else { // the default behaviour is to check all concurrent tokens and reactivate // the parent if the last token arrives in the join - reactivateParent = mustParentBeReactivated(parentToken, parentToken.getChildren().keySet().iterator() ); + reactivateParent = mustParentBeReactivated(parentToken, parentToken.getChildren() + .keySet() + .iterator()); } // if the parent token needs to be reactivated from this join node @@ -193,8 +197,8 @@ // write to all child tokens that the parent is already reactivated Iterator iter = parentToken.getChildren().values().iterator(); - while ( iter.hasNext() ) { - ((Token)iter.next()).setAbleToReactivateParent( false ); + while (iter.hasNext()) { + ((Token) iter.next()).setAbleToReactivateParent(false); } // write to all child tokens that the parent is already reactivated @@ -207,14 +211,15 @@ public boolean mustParentBeReactivated(Token parentToken, Iterator childTokenNameIterator) { boolean reactivateParent = true; - while ( (childTokenNameIterator.hasNext()) - && (reactivateParent) ){ + while ((childTokenNameIterator.hasNext()) && (reactivateParent)) { String concurrentTokenName = (String) childTokenNameIterator.next(); - - Token concurrentToken = parentToken.getChild( concurrentTokenName ); - + + Token concurrentToken = parentToken.getChild(concurrentTokenName); + if (concurrentToken.isAbleToReactivateParent()) { - log.debug("join will not yet reactivate parent: found concurrent token '"+concurrentToken+"'"); + log.debug("join will not yet reactivate parent: found concurrent token '" + + concurrentToken + + "'"); reactivateParent = false; } } @@ -224,30 +229,39 @@ public String getParentLockMode() { return parentLockMode; } + public void setParentLockMode(String parentLockMode) { this.parentLockMode = parentLockMode; } + public Script getScript() { return script; } + public void setScript(Script script) { this.script = script; } + public Collection getTokenNames() { return tokenNames; } + public void setTokenNames(Collection tokenNames) { this.tokenNames = tokenNames; } + public boolean isDiscriminator() { return isDiscriminator; } + public void setDiscriminator(boolean isDiscriminator) { this.isDiscriminator = isDiscriminator; } + public int getNOutOfM() { return nOutOfM; } + public void setNOutOfM(int nOutOfM) { this.nOutOfM = nOutOfM; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/StartState.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/StartState.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/StartState.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -24,6 +24,7 @@ import java.util.Map; import org.dom4j.Element; + import org.jbpm.graph.def.Event; import org.jbpm.graph.def.Node; import org.jbpm.graph.def.Transition; @@ -31,9 +32,9 @@ import org.jbpm.jpdl.xml.JpdlXmlReader; public class StartState extends Node { - + private static final long serialVersionUID = 1L; - + public StartState() { } @@ -41,24 +42,19 @@ super(name); } - @Override - public String getName() - { + public String getName() { return name; } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.StartState; } // event types ////////////////////////////////////////////////////////////// - public static final String[] supportedEventTypes = new String[]{ - Event.EVENTTYPE_NODE_LEAVE, - Event.EVENTTYPE_AFTER_SIGNAL - }; + public static final String[] supportedEventTypes = new String[] { Event.EVENTTYPE_NODE_LEAVE, + Event.EVENTTYPE_AFTER_SIGNAL }; + public String[] getSupportedEventTypes() { return supportedEventTypes; } @@ -68,7 +64,7 @@ public void read(Element startStateElement, JpdlXmlReader jpdlReader) { // if the start-state has a task specified, Element startTaskElement = startStateElement.element("task"); - if (startTaskElement!=null) { + if (startTaskElement != null) { // delegate the parsing of the start-state task to the jpdlReader jpdlReader.readStartStateTask(startTaskElement, this); } @@ -76,23 +72,24 @@ public void write(Element nodeElement) { } - + public void leave(ExecutionContext executionContext, Transition transition) { // leave this node as usual super.leave(executionContext, transition); } - + public void execute(ExecutionContext executionContext) { } - + public Transition addArrivingTransition(Transition t) { - throw new UnsupportedOperationException( "illegal operation : its not possible to add a transition that is arriving in a start state" ); + throw new UnsupportedOperationException( + "illegal operation : its not possible to add a transition that is arriving in a start state"); } - + public void setArrivingTransitions(Map arrivingTransitions) { - if ( (arrivingTransitions!=null) - && (arrivingTransitions.size()>0)) { - throw new UnsupportedOperationException( "illegal operation : its not possible to set a non-empty map in the arriving transitions of a start state" ); + if ((arrivingTransitions != null) && (arrivingTransitions.size() > 0)) { + throw new UnsupportedOperationException( + "illegal operation : its not possible to set a non-empty map in the arriving transitions of a start state"); } } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/State.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/State.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/State.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,28 +21,25 @@ */ package org.jbpm.graph.node; -import org.jbpm.graph.def.*; -import org.jbpm.graph.exe.*; +import org.jbpm.graph.def.Node; +import org.jbpm.graph.exe.ExecutionContext; public class State extends Node { - + private static final long serialVersionUID = 1L; public State() { this(null); } - + public State(String name) { - super( name ); + super(name); } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.State; } - public void execute(ExecutionContext executionContext) - { + public void execute(ExecutionContext executionContext) { } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/TaskNode.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/TaskNode.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/graph/node/TaskNode.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,20 +21,29 @@ */ package org.jbpm.graph.node; -import java.util.*; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; import org.dom4j.Element; -import org.jbpm.graph.def.*; -import org.jbpm.graph.exe.*; + +import org.jbpm.graph.def.Node; +import org.jbpm.graph.def.Transition; +import org.jbpm.graph.exe.ExecutionContext; +import org.jbpm.graph.exe.Token; import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator; -import org.jbpm.jpdl.xml.*; -import org.jbpm.taskmgmt.def.*; -import org.jbpm.taskmgmt.exe.*; +import org.jbpm.jpdl.xml.JpdlXmlReader; +import org.jbpm.jpdl.xml.Parsable; +import org.jbpm.taskmgmt.def.Task; +import org.jbpm.taskmgmt.exe.TaskInstance; +import org.jbpm.taskmgmt.exe.TaskMgmtInstance; /** - * is a node that relates to one or more tasks. - * Property <code>signal</code> specifies how task completion - * triggers continuation of execution. + * is a node that relates to one or more tasks. Property <code>signal</code> specifies how task + * completion triggers continuation of execution. */ public class TaskNode extends Node implements Parsable { @@ -49,65 +58,76 @@ */ public static final int SIGNAL_NEVER = 1; /** - * proceeds execution when the first task instance is completed. - * when no tasks are created on entrance of this node, execution is continued. + * proceeds execution when the first task instance is completed. when no tasks are created on + * entrance of this node, execution is continued. */ public static final int SIGNAL_FIRST = 2; /** - * proceeds execution when the first task instance is completed. - * when no tasks are created on entrance of this node, execution waits in the task node till tasks are created. + * proceeds execution when the first task instance is completed. when no tasks are created on + * entrance of this node, execution waits in the task node till tasks are created. */ public static final int SIGNAL_FIRST_WAIT = 3; /** - * proceeds execution when the last task instance is completed. - * when no tasks are created on entrance of this node, execution is continued. + * proceeds execution when the last task instance is completed. when no tasks are created on + * entrance of this node, execution is continued. */ public static final int SIGNAL_LAST = 4; /** - * proceeds execution when the last task instance is completed. - * when no tasks are created on entrance of this node, execution waits in the task node till tasks are created. + * proceeds execution when the last task instance is completed. when no tasks are created on + * entrance of this node, execution waits in the task node till tasks are created. */ public static final int SIGNAL_LAST_WAIT = 5; - + public static int parseSignal(String text) { if ("unsynchronized".equalsIgnoreCase(text)) { return SIGNAL_UNSYNCHRONIZED; - } else if ("never".equalsIgnoreCase(text)) { + } + else if ("never".equalsIgnoreCase(text)) { return SIGNAL_NEVER; - } else if ("first".equalsIgnoreCase(text)) { + } + else if ("first".equalsIgnoreCase(text)) { return SIGNAL_FIRST; - } else if ("first-wait".equalsIgnoreCase(text)) { + } + else if ("first-wait".equalsIgnoreCase(text)) { return SIGNAL_FIRST_WAIT; - } else if ("last-wait".equalsIgnoreCase(text)) { + } + else if ("last-wait".equalsIgnoreCase(text)) { return SIGNAL_LAST_WAIT; - } else { // return default + } + else { // return default return SIGNAL_LAST; } } - + public static String signalToString(int signal) { - if (signal==SIGNAL_UNSYNCHRONIZED) { + if (signal == SIGNAL_UNSYNCHRONIZED) { return "unsynchronized"; - } else if (signal==SIGNAL_NEVER) { + } + else if (signal == SIGNAL_NEVER) { return "never"; - } else if (signal==SIGNAL_FIRST) { + } + else if (signal == SIGNAL_FIRST) { return "first"; - } else if (signal==SIGNAL_FIRST_WAIT) { + } + else if (signal == SIGNAL_FIRST_WAIT) { return "first-wait"; - } else if (signal==SIGNAL_LAST) { + } + else if (signal == SIGNAL_LAST) { return "last"; - } else if (signal==SIGNAL_LAST_WAIT) { + } + else if (signal == SIGNAL_LAST_WAIT) { return "last-wait"; - } else { + } + else { return null; } } - + Set tasks = null; int signal = SIGNAL_LAST; boolean createTasks = true; boolean endTasks = false; - + public TaskNode() { } @@ -115,57 +135,52 @@ super(name); } - @Override - public NodeType getNodeType() - { + public NodeType getNodeType() { return NodeType.Task; } public void read(Element element, JpdlXmlReader jpdlReader) { // get the signal String signalText = element.attributeValue("signal"); - if (signalText!=null) { + if (signalText != null) { signal = parseSignal(signalText); } // create tasks String createTasksText = element.attributeValue("create-tasks"); - if (createTasksText!=null) { - if (("no".equalsIgnoreCase(createTasksText)) - || ("false".equalsIgnoreCase(createTasksText)) ) { + if (createTasksText != null) { + if (("no".equalsIgnoreCase(createTasksText)) || ("false".equalsIgnoreCase(createTasksText))) { createTasks = false; } } - + // create tasks String removeTasksText = element.attributeValue("end-tasks"); - if (removeTasksText!=null) { - if (("yes".equalsIgnoreCase(removeTasksText)) - || ("true".equalsIgnoreCase(removeTasksText)) ) { + if (removeTasksText != null) { + if (("yes".equalsIgnoreCase(removeTasksText)) || ("true".equalsIgnoreCase(removeTasksText))) { endTasks = true; } } - + // parse the tasks jpdlReader.readTasks(element, this); } public void addTask(Task task) { - if (tasks==null) tasks = new HashSet(); + if (tasks == null) tasks = new HashSet(); tasks.add(task); task.setTaskNode(this); } // node behaviour methods ///////////////////////////////////////////////////////////////////////////// - + public void execute(ExecutionContext executionContext) { - + TaskMgmtInstance tmi = getTaskMgmtInstance(executionContext.getToken()); - + // if this tasknode should create instances - if ( (createTasks) - && (tasks!=null) ) { + if ((createTasks) && (tasks != null)) { Iterator iter = tasks.iterator(); while (iter.hasNext()) { Task task = (Task) iter.next(); @@ -179,24 +194,24 @@ // check if we should continue execution boolean continueExecution; switch (signal) { - case SIGNAL_UNSYNCHRONIZED: - continueExecution = true; - break; - case SIGNAL_FIRST: - case SIGNAL_LAST: - continueExecution = tmi.getSignallingTasks(executionContext).isEmpty(); - break; - default: - continueExecution = false; + case SIGNAL_UNSYNCHRONIZED: + continueExecution = true; + break; + case SIGNAL_FIRST: + case SIGNAL_LAST: + continueExecution = tmi.getSignallingTasks(executionContext).isEmpty(); + break; + default: + continueExecution = false; } if (continueExecution) { leave(executionContext); } } - + boolean evaluateTaskCondition(String condition, ExecutionContext executionContext) { - if (condition==null) return true; + if (condition == null) return true; Object result = JbpmExpressionEvaluator.evaluate(condition, executionContext); if (Boolean.TRUE.equals(result)) { return true; @@ -206,13 +221,13 @@ public void leave(ExecutionContext executionContext, Transition transition) { TaskMgmtInstance tmi = getTaskMgmtInstance(executionContext.getToken()); - if (tmi.hasBlockingTaskInstances(executionContext.getToken()) ) { - throw new IllegalStateException("task-node '"+name+"' still has blocking tasks"); + if (tmi.hasBlockingTaskInstances(executionContext.getToken())) { + throw new IllegalStateException("task-node '" + name + "' still has blocking tasks"); } removeTaskInstanceSynchronization(executionContext.getToken()); super.leave(executionContext, transition); } - + // task behaviour methods ///////////////////////////////////////////////////////////////////////////// @@ -236,29 +251,27 @@ boolean isLastToComplete(TaskInstance taskInstance) { Token token = taskInstance.getToken(); TaskMgmtInstance tmi = getTaskMgmtInstance(token); - + boolean isLastToComplete = true; Iterator iter = tmi.getTaskInstances().iterator(); - while ( iter.hasNext() - && (isLastToComplete) ) { + while (iter.hasNext() && (isLastToComplete)) { TaskInstance other = (TaskInstance) iter.next(); - if ( (token!=null) - && (token.equals(other.getToken())) - && (! other.equals(taskInstance)) - && (other.isSignalling()) - && (!other.hasEnded()) - ) { + if ((token != null) + && (token.equals(other.getToken())) + && (!other.equals(taskInstance)) + && (other.isSignalling()) + && (!other.hasEnded())) { isLastToComplete = false; } } - + return isLastToComplete; } public void removeTaskInstanceSynchronization(Token token) { TaskMgmtInstance tmi = getTaskMgmtInstance(token); Collection taskInstances = tmi.getTaskInstances(); - if (taskInstances!=null) { + if (taskInstances != null) { Iterator iter = taskInstances.iterator(); while (iter.hasNext()) { TaskInstance taskInstance = (TaskInstance) iter.next(); @@ -273,9 +286,7 @@ } // if this is a non-finished task and all those // tasks should be finished - if ( (! taskInstance.hasEnded()) - && (endTasks) - ) { + if ((!taskInstance.hasEnded()) && (endTasks)) { if (tasks.contains(taskInstance.getTask())) { // end this task taskInstance.end(); @@ -294,12 +305,12 @@ ///////////////////////////////////////////////////////////////////////////// /** - * is a Map with the tasks, keyed by task-name or an empty map in case - * no tasks are present in this task-node. + * is a Map with the tasks, keyed by task-name or an empty map in case no tasks are present in + * this task-node. */ public Map getTasksMap() { Map tasksMap = new HashMap(); - if (tasks!=null) { + if (tasks != null) { Iterator iter = tasks.iterator(); while (iter.hasNext()) { Task task = (Task) iter.next(); @@ -308,10 +319,10 @@ } return tasksMap; } - + /** - * is the task in this task-node with the given name or null if the given task - * does not exist in this node. + * is the task in this task-node with the given name or null if the given task does not exist in + * this node. */ public Task getTask(String taskName) { return (Task) getTasksMap().get(taskName); @@ -320,24 +331,31 @@ public Set getTasks() { return tasks; } + public int getSignal() { return signal; } + public boolean getCreateTasks() { return createTasks; } + public boolean isEndTasks() { return endTasks; } + public void setCreateTasks(boolean createTasks) { this.createTasks = createTasks; } + public void setEndTasks(boolean endTasks) { this.endTasks = endTasks; } + public void setSignal(int signal) { this.signal = signal; } + public void setTasks(Set tasks) { this.tasks = tasks; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/Timer.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/Timer.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/Timer.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,6 +5,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.calendar.BusinessCalendar; import org.jbpm.calendar.Duration; @@ -20,13 +21,13 @@ private final static String dateFormat = "yyyy-MM-dd HH:mm:ss,SSS"; static BusinessCalendar businessCalendar = new BusinessCalendar(); - + String name; String repeat; String transitionName = null; Action action = null; GraphElement graphElement = null; - + public Timer() { } @@ -38,25 +39,27 @@ ExecutionContext executionContext = new ExecutionContext(token); executionContext.setTimer(this); - if (taskInstance!=null) { + if (taskInstance != null) { executionContext.setTaskInstance(taskInstance); } // first fire the event if there is a graph element specified - if (graphElement!=null) { + if (graphElement != null) { graphElement.fireAndPropagateEvent(Event.EVENTTYPE_TIMER, executionContext); } // then execute the action if there is one - if (action!=null) { + if (action != null) { try { - log.debug("executing '"+this+"'"); - if (graphElement!=null) { + log.debug("executing '" + this + "'"); + if (graphElement != null) { graphElement.executeAction(action, executionContext); - } else { + } + else { action.execute(executionContext); } - } catch (Exception actionException) { + } + catch (Exception actionException) { // NOTE that Error's are not caught because that might halt the JVM and mask the original Error. log.warn("timer action threw exception", actionException); // if there is a graphElement connected to this timer... @@ -64,28 +67,29 @@ try { // we give that graphElement a chance to catch the exception graphElement.raiseException(actionException, executionContext); - log.debug("timer exception got handled by '"+graphElement+"'"); - } catch (Exception handlerException) { + log.debug("timer exception got handled by '" + graphElement + "'"); + } + catch (Exception handlerException) { // if the exception handler rethrows or the original exception results in a DelegationException... throw handlerException; } - } else { + } + else { throw actionException; } } } // then take a transition if one is specified - if ( (transitionName!=null) - && (exception==null) // and if no unhandled exception occurred during the action - ) { + if ((transitionName != null) && (exception == null) // and if no unhandled exception occurred during the action + ) { if (token.getNode().hasLeavingTransition(transitionName)) { token.signal(transitionName); } } // if repeat is specified, reschedule the job - if (repeat!=null) { + if (repeat != null) { // suppose that it took the timer runner thread a // very long time to execute the timers. // then the repeat action dueDate could already have passed. @@ -108,26 +112,22 @@ return false; } - + return true; } - + public String toString() { - StringBuilder text = new StringBuilder("Timer"); + StringBuffer text = new StringBuffer("Timer"); if (name != null || dueDate != null) { text.append('('); - if (name!=null) - text.append(name).append(","); - if (dueDate!=null) - text.append(formatDueDate(dueDate)).append(","); - if (taskInstance!=null) - text.append(taskInstance).append(","); + if (name != null) text.append(name).append(","); + if (dueDate != null) text.append(formatDueDate(dueDate)).append(","); + if (taskInstance != null) text.append(taskInstance).append(","); - if (token!=null) + if (token != null) text.append(token); - else if (processInstance!=null) - text.append(processInstance); + else if (processInstance != null) text.append(processInstance); text.append(')'); } @@ -141,33 +141,42 @@ public String getRepeat() { return repeat; } + public void setRepeat(String repeat) { this.repeat = repeat; } + public String getName() { return name; } + public void setName(String name) { this.name = name; } + public String getTransitionName() { return transitionName; } + public void setTransitionName(String transitionName) { this.transitionName = transitionName; } + public GraphElement getGraphElement() { return graphElement; } + public void setGraphElement(GraphElement graphElement) { this.graphElement = graphElement; } + public Action getAction() { return action; } + public void setAction(Action action) { this.action = action; } - + private static Log log = LogFactory.getLog(Timer.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/JobExecutorThread.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/JobExecutorThread.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/JobExecutorThread.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -18,18 +18,14 @@ import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.job.Job; import org.jbpm.persistence.JbpmPersistenceException; +import org.jbpm.persistence.db.StaleObjectLogConfigurer; import org.jbpm.svc.Services; public class JobExecutorThread extends Thread { - public JobExecutorThread( String name, - JobExecutor jobExecutor, - JbpmConfiguration jbpmConfiguration, - int idleInterval, - int maxIdleInterval, - long maxLockTime, - int maxHistory - ) { + public JobExecutorThread(String name, JobExecutor jobExecutor, + JbpmConfiguration jbpmConfiguration, int idleInterval, int maxIdleInterval, long maxLockTime, + int maxHistory) { super(name); this.jobExecutor = jobExecutor; this.jbpmConfiguration = jbpmConfiguration; @@ -38,7 +34,7 @@ this.maxLockTime = maxLockTime; } - final JobExecutor jobExecutor; + final JobExecutor jobExecutor; final JbpmConfiguration jbpmConfiguration; final int idleInterval; final int maxIdleInterval; @@ -52,39 +48,35 @@ while (isActive) { try { Collection acquiredJobs = acquireJobs(); - - if (! acquiredJobs.isEmpty()) { - Iterator iter = acquiredJobs.iterator(); - while (iter.hasNext() && isActive) { - Job job = (Job) iter.next(); + if (!acquiredJobs.isEmpty()) { + for (Iterator i = acquiredJobs.iterator(); i.hasNext() && isActive;) { + Job job = (Job) i.next(); executeJob(job); } - - } else { // no jobs acquired - if (isActive) { - long waitPeriod = getWaitPeriod(); - if (waitPeriod>0) { - synchronized(jobExecutor) { - jobExecutor.wait(waitPeriod); - } + } + if (isActive) { + long waitPeriod = getWaitPeriod(); + if (waitPeriod > 0) { + synchronized (jobExecutor) { + jobExecutor.wait(waitPeriod); } } } - - // no exception so resetting the currentIdleInterval + // no exception, reset current idle interval currentIdleInterval = idleInterval; - - } catch (InterruptedException e) { - log.info((isActive? "active" : "inactive")+" job executor thread '"+getName()+"' got interrupted"); - } catch (Exception e) { - log.error("exception in job executor thread. waiting "+currentIdleInterval+" milliseconds", e); + } + catch (RuntimeException e) { + log.error("exception in job executor thread. waiting " + + currentIdleInterval + + " milliseconds", e); try { - synchronized(jobExecutor) { + synchronized (jobExecutor) { jobExecutor.wait(currentIdleInterval); } - } catch (InterruptedException e2) { - log.debug("delay after exception got interrupted", e2); } + catch (InterruptedException ie) { + log.debug("delay after exception got interrupted", ie); + } // after an exception, the current idle interval is doubled to prevent // continuous exception generation when e.g. the db is unreachable currentIdleInterval <<= 1; @@ -92,8 +84,11 @@ currentIdleInterval = maxIdleInterval; } } + catch (InterruptedException e) { + log.info("job executor thread '" + getName() + "' got interrupted"); + } } - log.info(getName()+" leaves cyberspace"); + log.info(getName() + " leaves cyberspace"); } protected Collection acquireJobs() { @@ -107,46 +102,51 @@ String lockOwner = getName(); log.debug("querying for acquirable job..."); Job job = jobSession.getFirstAcquirableJob(lockOwner); - if (job!=null) { + if (job != null) { if (job.isExclusive()) { - log.debug("found exclusive " + job); + log.debug("obtained exclusive " + job); ProcessInstance processInstance = job.getProcessInstance(); log.debug("finding other exclusive jobs for " + processInstance); jobsToLock = jobSession.findExclusiveJobs(lockOwner, processInstance); - log.debug("trying to obtain exclusive locks on " + jobsToLock + " for " + processInstance); - } else { + log.debug("trying to obtain exclusive locks on " + + jobsToLock + + " for " + + processInstance); + } + else { log.debug("trying to obtain lock on " + job); jobsToLock = Collections.singletonList(job); } - + Date lockTime = new Date(); - for (Iterator iter = jobsToLock.iterator(); iter.hasNext();) { - job = (Job) iter.next(); + for (Iterator i = jobsToLock.iterator(); i.hasNext();) { + job = (Job) i.next(); job.setLockOwner(lockOwner); job.setLockTime(lockTime); - // jbpmContext.getSession().update(job); } - - // HACKY HACK : this is a workaround for a hibernate problem that is fixed in hibernate 3.2.1 - // TODO remove this hack already? - // if (job instanceof Timer) { - // Hibernate.initialize(((Timer)job).getGraphElement()); - // } - } else { + } + else { log.debug("no acquirable jobs in job table"); } - } finally { + } + catch (RuntimeException e) { + jbpmContext.setRollbackOnly(); + throw e; + } + finally { try { jbpmContext.close(); acquiredJobs = jobsToLock; - log.debug("obtained lock on jobs: "+acquiredJobs); + log.debug("acquired lock on jobs: " + acquiredJobs); } catch (JbpmPersistenceException e) { // if this is a stale object exception, keep it quiet if (Services.isCausedByStaleState(e)) { - log.debug("optimistic locking failed, couldn't obtain lock on jobs "+jobsToLock); + StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error( + "failed to acquire lock on jobs " + jobsToLock); acquiredJobs = Collections.EMPTY_LIST; - } else { + } + else { throw e; } } @@ -170,33 +170,38 @@ if (job.execute(jbpmContext)) { jobSession.deleteJob(job); } - } catch (Exception e) { + } + catch (Exception e) { log.debug("exception while executing " + job, e); if (!isPersistenceException(e)) { StringWriter memoryWriter = new StringWriter(); e.printStackTrace(new PrintWriter(memoryWriter)); job.setException(memoryWriter.toString()); - job.setRetries(job.getRetries()-1); + job.setRetries(job.getRetries() - 1); } else { // allowing a transaction to proceed after a persistence exception is unsafe jbpmContext.setRollbackOnly(); } } - + // if this job is locked too long - long totalLockTimeInMillis = System.currentTimeMillis() - job.getLockTime().getTime(); - if (totalLockTimeInMillis>maxLockTime) { + long totalLockTimeInMillis = System.currentTimeMillis() - job.getLockTime().getTime(); + if (totalLockTimeInMillis > maxLockTime) { jbpmContext.setRollbackOnly(); } - } finally { + } + finally { try { jbpmContext.close(); - } catch (JbpmPersistenceException e) { + } + catch (JbpmPersistenceException e) { // if this is a stale state exception, keep it quiet if (Services.isCausedByStaleState(e)) { - log.debug("optimistic locking failed, couldn't complete job "+job); - } else { + StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error( + "failed to complete job " + job); + } + else { throw e; } } @@ -205,8 +210,7 @@ private static boolean isPersistenceException(Throwable throwable) { do { - if (throwable instanceof HibernateException) - return true; + if (throwable instanceof HibernateException) return true; throwable = throwable.getCause(); } while (throwable != null); return false; @@ -214,24 +218,33 @@ protected Date getNextDueDate() { Date nextDueDate = null; + String threadName = getName(); JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); try { JobSession jobSession = jbpmContext.getJobSession(); Collection jobIdsToIgnore = jobExecutor.getMonitoredJobIds(); - Job job = jobSession.getFirstDueJob(getName(), jobIdsToIgnore); - if (job!=null) { + Job job = jobSession.getFirstDueJob(threadName, jobIdsToIgnore); + if (job != null) { nextDueDate = job.getDueDate(); - jobExecutor.addMonitoredJobId(getName(), job.getId()); + jobExecutor.addMonitoredJobId(threadName, job.getId()); } - } finally { + } + catch (RuntimeException e) { + jbpmContext.setRollbackOnly(); + throw e; + } + finally { try { jbpmContext.close(); - } catch (JbpmPersistenceException e) { + } + catch (JbpmPersistenceException e) { // if this is a stale object exception, keep it quiet if (Services.isCausedByStaleState(e)) { - log.debug("optimistic locking failed, couldn't get next due date"); + StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error( + "failed to determine next due date for job executor thread " + threadName); nextDueDate = null; - } else { + } + else { throw e; } } @@ -242,14 +255,14 @@ protected long getWaitPeriod() { long interval = currentIdleInterval; Date nextDueDate = getNextDueDate(); - if (nextDueDate!=null) { + if (nextDueDate != null) { long currentTime = System.currentTimeMillis(); long nextDueTime = nextDueDate.getTime(); - if (nextDueTime < currentTime+currentIdleInterval) { - interval = nextDueTime-currentTime; + if (nextDueTime < currentTime + currentIdleInterval) { + interval = nextDueTime - currentTime; } } - if (interval<0) { + if (interval < 0) { interval = 0; } return interval; @@ -259,18 +272,16 @@ * @deprecated As of jBPM 3.2.3, replaced by {@link #deactivate()} */ public void setActive(boolean isActive) { - if (isActive == false) - deactivate(); + if (isActive == false) deactivate(); } /** - * Indicates that this thread should stop running. - * Execution will cease shortly afterwards. + * Indicates that this thread should stop running. Execution will cease shortly afterwards. */ public void deactivate() { if (isActive) { isActive = false; - interrupt(); + interrupt(); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/LockMonitorThread.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/LockMonitorThread.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/job/executor/LockMonitorThread.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,10 +1,12 @@ package org.jbpm.job.executor; import java.util.Date; +import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; import org.jbpm.db.JobSession; @@ -15,67 +17,77 @@ public class LockMonitorThread extends Thread { - JbpmConfiguration jbpmConfiguration; - int lockMonitorInterval; - int maxLockTime; - int lockBufferTime; + final JbpmConfiguration jbpmConfiguration; + final int lockMonitorInterval; + final int maxLockMonitorInterval; + final int maxLockTime; + final int lockBufferTime; + int currentLockMonitorInterval; volatile boolean isActive = true; public LockMonitorThread(JbpmConfiguration jbpmConfiguration, int lockMonitorInterval, int maxLockTime, int lockBufferTime) { this.jbpmConfiguration = jbpmConfiguration; this.lockMonitorInterval = lockMonitorInterval; + this.maxLockMonitorInterval = jbpmConfiguration.getJobExecutor().getMaxIdleInterval(); this.maxLockTime = maxLockTime; this.lockBufferTime = lockBufferTime; } public void run() { - try { - while (isActive) { + currentLockMonitorInterval = lockMonitorInterval; + while (isActive) { + try { + unlockOverdueJobs(); + if (isActive) { + sleep(currentLockMonitorInterval); + } + // no exception, reset current lock monitor interval + currentLockMonitorInterval = lockMonitorInterval; + } + catch (RuntimeException e) { + log.error("exception in lock monitor thread. waiting " + + currentLockMonitorInterval + + " milliseconds", e); try { - unlockOverdueJobs(); - if ((isActive) && (lockMonitorInterval > 0)) { - sleep(lockMonitorInterval); - } + sleep(currentLockMonitorInterval); } - catch (InterruptedException e) { - log.info("lock monitor thread '" + getName() + "' got interrupted"); + catch (InterruptedException ie) { + log.debug("delay after exception got interrupted", ie); } - catch (Exception e) { - log.error("exception in lock monitor thread. waiting " - + lockMonitorInterval - + " milliseconds", e); - try { - sleep(lockMonitorInterval); - } - catch (InterruptedException e2) { - log.debug("delay after exception got interrupted", e2); - } + // after an exception, double the current lock monitor interval to prevent + // continuous exception generation when e.g. the db is unreachable + currentLockMonitorInterval <<= 1; + if (currentLockMonitorInterval > maxLockMonitorInterval || currentLockMonitorInterval < 0) { + currentLockMonitorInterval = maxLockMonitorInterval; } } + catch (InterruptedException e) { + log.info("lock monitor thread '" + getName() + "' got interrupted"); + } } - catch (Exception e) { - log.error("exception in lock monitor thread", e); - } - finally { - log.info(getName() + " leaves cyberspace"); - } + log.info(getName() + " leaves cyberspace"); } protected void unlockOverdueJobs() { - List<Job> overdueJobs = null; + List overdueJobs = null; JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); try { Date threshold = new Date(System.currentTimeMillis() - maxLockTime - lockBufferTime); JobSession jobSession = jbpmContext.getJobSession(); overdueJobs = jobSession.findJobsWithOverdueLockTime(threshold); - for (Job job : overdueJobs) { + for (Iterator i = overdueJobs.iterator(); i.hasNext();) { + Job job = (Job) i.next(); log.debug("unlocking " + job + " owned by thread " + job.getLockOwner()); job.setLockOwner(null); job.setLockTime(null); } } + catch (RuntimeException e) { + jbpmContext.setRollbackOnly(); + throw e; + } finally { try { jbpmContext.close(); @@ -83,9 +95,8 @@ catch (JbpmPersistenceException e) { // if this is a stale object exception, keep it quiet if (Services.isCausedByStaleState(e)) { - log.debug("optimistic locking failed, could not unlock overdue jobs: " + overdueJobs); StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error( - "problem unlocking overdue jobs: optimistic locking failed", e); + "optimistic locking failed, could not unlock overdue jobs: " + overdueJobs); } else { throw e; Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/jpdl/xml/JpdlXmlWriter.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/jpdl/xml/JpdlXmlWriter.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/jpdl/xml/JpdlXmlWriter.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,172 +21,189 @@ */ package org.jbpm.jpdl.xml; -import java.io.*; -import java.util.*; +import java.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.Map; -import org.dom4j.*; -import org.dom4j.io.*; +import org.dom4j.Document; +import org.dom4j.DocumentHelper; +import org.dom4j.Element; +import org.dom4j.Namespace; +import org.dom4j.io.OutputFormat; +import org.dom4j.io.XMLWriter; + import org.jbpm.JbpmException; import org.jbpm.graph.action.ActionTypes; -import org.jbpm.graph.def.*; -import org.jbpm.graph.node.*; -import org.jbpm.jpdl.*; +import org.jbpm.graph.def.Action; +import org.jbpm.graph.def.Event; +import org.jbpm.graph.def.GraphElement; +import org.jbpm.graph.def.ProcessDefinition; +import org.jbpm.graph.def.Transition; +import org.jbpm.graph.node.ProcessFactory; +import org.jbpm.graph.node.StartState; +import org.jbpm.jpdl.JpdlException; /** - * @deprecated xml generation was never finished and will be removed in the future. + * Class for writing process definitions to character streams. + * <p> + * Saving process definitions to XML is in no way complete, but may be useful for process + * definitions with no custom nodes. + * </p> */ public class JpdlXmlWriter { static final String JPDL_NAMESPACE = "http://jbpm.org/3/jpdl"; static final Namespace jbpmNamespace = new Namespace(null, JPDL_NAMESPACE); - + Writer writer = null; List problems = new ArrayList(); boolean useNamespace = false; - public JpdlXmlWriter( Writer writer ) { - if (writer==null) throw new JbpmException("writer is null"); + public JpdlXmlWriter(Writer writer) { + if (writer == null) throw new JbpmException("writer is null"); this.writer = writer; } - + public void addProblem(String msg) { problems.add(msg); } + public static String toString(ProcessDefinition processDefinition) { StringWriter stringWriter = new StringWriter(); JpdlXmlWriter jpdlWriter = new JpdlXmlWriter(stringWriter); jpdlWriter.write(processDefinition); return stringWriter.toString(); } - - public void setUseNamespace(boolean useNamespace) - { - this.useNamespace = useNamespace; + + public void setUseNamespace(boolean useNamespace) { + this.useNamespace = useNamespace; } - + //newElement.add( jbpmNamespace ); public void write(ProcessDefinition processDefinition) { problems = new ArrayList(); - if (processDefinition==null) throw new JbpmException("processDefinition is null"); + if (processDefinition == null) throw new JbpmException("processDefinition is null"); try { // collect the actions of the process definition // we will remove each named event action and the remaining ones will be written // on the process definition. // create a dom4j dom-tree for the process definition Document document = createDomTree(processDefinition); - + // write the dom-tree to the given writer - OutputFormat outputFormat = new OutputFormat( " ", true ); + OutputFormat outputFormat = new OutputFormat(" ", true); // OutputFormat outputFormat = OutputFormat.createPrettyPrint(); - XMLWriter xmlWriter = new XMLWriter( writer, outputFormat ); - xmlWriter.write( document ); + XMLWriter xmlWriter = new XMLWriter(writer, outputFormat); + xmlWriter.write(document); xmlWriter.flush(); writer.flush(); - } catch (IOException e) { - addProblem("couldn't write process definition xml: "+e.getMessage()); } - - if (problems.size()>0) { + catch (IOException e) { + addProblem("couldn't write process definition xml: " + e.getMessage()); + } + + if (problems.size() > 0) { throw new JpdlException(problems); } } - + private Document createDomTree(ProcessDefinition processDefinition) { Document document = DocumentHelper.createDocument(); Element root = null; - - if (useNamespace) - root = document.addElement( "process-definition", jbpmNamespace.getURI() ); - else - root = document.addElement( "process-definition" - ); - addAttribute( root, "name", processDefinition.getName() ); + if (useNamespace) + root = document.addElement("process-definition", jbpmNamespace.getURI()); + else + root = document.addElement("process-definition"); + addAttribute(root, "name", processDefinition.getName()); + // write the start-state - if ( processDefinition.getStartState()!=null ) { + if (processDefinition.getStartState() != null) { writeComment(root, "START-STATE"); - writeStartNode( root, (StartState) processDefinition.getStartState() ); + writeStartNode(root, (StartState) processDefinition.getStartState()); } // write the nodeMap - if ( ( processDefinition.getNodes()!=null ) - && ( processDefinition.getNodes().size() > 0 ) ) { + if ((processDefinition.getNodes() != null) && (processDefinition.getNodes().size() > 0)) { writeComment(root, "NODES"); - writeNodes( root, processDefinition.getNodes() ); + writeNodes(root, processDefinition.getNodes()); } // write the process level actions - if ( processDefinition.hasEvents() ) { + if (processDefinition.hasEvents()) { writeComment(root, "PROCESS-EVENTS"); - writeEvents( root, processDefinition ); + writeEvents(root, processDefinition); } - if( processDefinition.hasActions() ) { + if (processDefinition.hasActions()) { writeComment(root, "ACTIONS"); List namedProcessActions = getNamedProcessActions(processDefinition.getActions()); writeActions(root, namedProcessActions); } - root.addText( System.getProperty("line.separator") ); + root.addText(System.getProperty("line.separator")); return document; } - + private List getNamedProcessActions(Map actions) { List namedProcessActions = new ArrayList(); Iterator iter = actions.values().iterator(); while (iter.hasNext()) { Action action = (Action) iter.next(); - if ( (action.getEvent()==null) - && (action.getName()!=null) ) { + if ((action.getEvent() == null) && (action.getName() != null)) { namedProcessActions.add(action); } } return namedProcessActions; } - private void writeStartNode(Element element, StartState startState ) { - if (startState!=null) { - writeNode( addElement( element, getTypeName(startState) ), startState ); + private void writeStartNode(Element element, StartState startState) { + if (startState != null) { + writeNode(addElement(element, getTypeName(startState)), startState); } } - + private void writeNodes(Element parentElement, Collection nodes) { Iterator iter = nodes.iterator(); while (iter.hasNext()) { org.jbpm.graph.def.Node node = (org.jbpm.graph.def.Node) iter.next(); - if ( ! (node instanceof StartState) ) { - Element nodeElement = addElement( parentElement, ProcessFactory.getTypeName(node) ); + if (!(node instanceof StartState)) { + Element nodeElement = addElement(parentElement, ProcessFactory.getTypeName(node)); node.write(nodeElement); - writeNode( nodeElement, node ); + writeNode(nodeElement, node); } } } - - private void writeNode(Element element, org.jbpm.graph.def.Node node ) { - addAttribute( element, "name", node.getName() ); + + private void writeNode(Element element, org.jbpm.graph.def.Node node) { + addAttribute(element, "name", node.getName()); writeTransitions(element, node); writeEvents(element, node); } private void writeTransitions(Element element, org.jbpm.graph.def.Node node) { - if ( node.getLeavingTransitionsMap()!=null ) { + if (node.getLeavingTransitionsMap() != null) { Iterator iter = node.getLeavingTransitionsList().iterator(); while (iter.hasNext()) { Transition transition = (Transition) iter.next(); - writeTransition( element.addElement("transition"), transition ); + writeTransition(element.addElement("transition"), transition); } } } private void writeTransition(Element transitionElement, Transition transition) { - if (transition.getTo()!=null) { - transitionElement.addAttribute( "to", transition.getTo().getName() ); + if (transition.getTo() != null) { + transitionElement.addAttribute("to", transition.getTo().getName()); } - if ( transition.getName()!=null ) { - transitionElement.addAttribute( "name", transition.getName() ); + if (transition.getName() != null) { + transitionElement.addAttribute("name", transition.getName()); } Event transitionEvent = transition.getEvent(Event.EVENTTYPE_TRANSITION); - if ( (transitionEvent!=null) - && (transitionEvent.hasActions()) ){ + if ((transitionEvent != null) && (transitionEvent.hasActions())) { writeActions(transitionElement, transitionEvent.getActions()); } } @@ -196,7 +213,7 @@ Iterator iter = graphElement.getEvents().values().iterator(); while (iter.hasNext()) { Event event = (Event) iter.next(); - writeEvent( element.addElement("event"), event ); + writeEvent(element.addElement("event"), event); } } } @@ -207,7 +224,7 @@ Iterator actionIter = event.getActions().iterator(); while (actionIter.hasNext()) { Action action = (Action) actionIter.next(); - writeAction( eventElement, action ); + writeAction(eventElement, action); } } } @@ -216,15 +233,15 @@ Iterator actionIter = actions.iterator(); while (actionIter.hasNext()) { Action action = (Action) actionIter.next(); - writeAction( parentElement, action ); + writeAction(parentElement, action); } } - private void writeAction(Element parentElement, Action action ) { + private void writeAction(Element parentElement, Action action) { String actionName = ActionTypes.getActionName(action.getClass()); Element actionElement = parentElement.addElement(actionName); - if (action.getName()!=null) { + if (action.getName() != null) { actionElement.addAttribute("name", action.getName()); } @@ -235,25 +252,25 @@ action.write(actionElement); } - private void writeComment(Element element, String comment ) { - element.addText( System.getProperty("line.separator") ); - element.addComment( " " + comment + " " ); + private void writeComment(Element element, String comment) { + element.addText(System.getProperty("line.separator")); + element.addComment(" " + comment + " "); } - private Element addElement( Element element, String elementName ) { - Element newElement = element.addElement( elementName ); + private Element addElement(Element element, String elementName) { + Element newElement = element.addElement(elementName); return newElement; } - private void addAttribute( Element e, String attributeName, String value ) { - if ( value != null ) { - e.addAttribute( attributeName, value ); + private void addAttribute(Element e, String attributeName, String value) { + if (value != null) { + e.addAttribute(attributeName, value); } } - private String getTypeName( Object o ) { - return ProcessFactory.getTypeName( (org.jbpm.graph.def.Node) o ); + private String getTypeName(Object o) { + return ProcessFactory.getTypeName((org.jbpm.graph.def.Node) o); } - + // private static final Log log = LogFactory.getLog(JpdlXmlWriter.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationService.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationService.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationService.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,59 +29,53 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; import org.jbpm.security.AuthenticationService; import org.jbpm.util.ClassLoaderUtil; /** - * gets the authenticated actor id from the current Subject. - * This Authenticator is either configured via the {@link SubjectAuthenticationServiceFactory} - * or it requires the two other configuration parameter - * 'jbpm.authenticator.principal.classname' and 'jbpm.authenticator.principal.allow.overwrite' - * This configuration property - * specifies the class name of the principal that should be used from - * the current subject. This could be for example org.jboss.security.CallerIdentity - * in an JBoss AS. - * - * If not actorId is set, the name of that principal is used as the - * currently authenticated actorId. If an actorId!=null is set (via setActorId) - * this one overwrites the principal. This behavior is configurable via - * the 'jbpm.authenticator.principal.allow.overwrite' attribute. If this - * is set to false, setActorId is simply ignored. - * + * gets the authenticated actor id from the current Subject. This Authenticator is either configured + * via the {@link SubjectAuthenticationServiceFactory} or it requires the two other configuration + * parameter 'jbpm.authenticator.principal.classname' and + * 'jbpm.authenticator.principal.allow.overwrite' This configuration property specifies the class + * name of the principal that should be used from the current subject. This could be for example + * org.jboss.security.CallerIdentity in an JBoss AS. If not actorId is set, the name of that + * principal is used as the currently authenticated actorId. If an actorId!=null is set (via + * setActorId) this one overwrites the principal. This behavior is configurable via the + * 'jbpm.authenticator.principal.allow.overwrite' attribute. If this is set to false, setActorId is + * simply ignored. */ public class SubjectAuthenticationService implements AuthenticationService { - + private static final long serialVersionUID = 1L; - + private static Log log = LogFactory.getLog(JbpmContext.class); - + private Class principalClass; - + private boolean allowActorIdOverwrite; - + private String actorId; - - public SubjectAuthenticationService(String principalClassName, Boolean allowActorIdOverwrite) - { - if (principalClassName!=null) { - initPrincipalClass( principalClassName ); + + public SubjectAuthenticationService(String principalClassName, Boolean allowActorIdOverwrite) { + if (principalClassName != null) { + initPrincipalClass(principalClassName); } else { - initPrincipalClass(JbpmConfiguration.Configs.getString("jbpm.authenticator.principal.classname") ); + initPrincipalClass(JbpmConfiguration.Configs.getString("jbpm.authenticator.principal.classname")); } - if (allowActorIdOverwrite!=null) { - this.allowActorIdOverwrite = allowActorIdOverwrite; + if (allowActorIdOverwrite != null) { + this.allowActorIdOverwrite = allowActorIdOverwrite.booleanValue(); } else { this.allowActorIdOverwrite = JbpmConfiguration.Configs.getBoolean("jbpm.authenticator.principal.allow.overwrite"); } } - public SubjectAuthenticationService() - { - initPrincipalClass(JbpmConfiguration.Configs.getString("jbpm.authenticator.principal.classname") ); + public SubjectAuthenticationService() { + initPrincipalClass(JbpmConfiguration.Configs.getString("jbpm.authenticator.principal.classname")); allowActorIdOverwrite = JbpmConfiguration.Configs.getBoolean("jbpm.authenticator.principal.allow.overwrite"); } @@ -90,18 +84,16 @@ } public String getActorId() { - if (actorId==null) { + if (actorId == null) { Subject subject = Subject.getSubject(AccessController.getContext()); - if (subject==null) { + if (subject == null) { log.warn("no javax.security.auth.Subject exists! Cannot set jbpm actorId"); return null; } - + Set principals = subject.getPrincipals(principalClass); - if ( (principals!=null) - && (!principals.isEmpty()) - ) { + if ((principals != null) && (!principals.isEmpty())) { // always use the first one (so be patient what Principal classes are used) Principal principal = (Principal) principals.iterator().next(); actorId = principal.getName(); @@ -110,14 +102,13 @@ return actorId; } - public void setActorId(String actorId) - { - if (allowActorIdOverwrite && actorId!=null) { + public void setActorId(String actorId) { + if (allowActorIdOverwrite && actorId != null) { this.actorId = actorId; } } - + public void close() { } - + } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationServiceFactory.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationServiceFactory.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/security/authentication/SubjectAuthenticationServiceFactory.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -25,39 +25,46 @@ import org.jbpm.svc.ServiceFactory; /** + * <p> * Factory to create a {@link SubjectAuthenticationService}. + * </p> + * <p> + * Two properties can be set: allowActorIdOverwrite & principalClassName + * </p> + * <p> + * principalClassName configuration property specifies the class name of the principal that should + * be used from the current subject. This could be for example org.jboss.security.CallerIdentity in + * an JBoss AS. + * </p> + * <p> + * If not actorId is set, the name of that principal is used as the currently authenticated actorId. + * If an actorId!=null is set (via setActorId) this one overwrites the principal. This behavior is + * configurable via the allowActorIdOverwrite attribute. If this is set to false, setActorId is + * simply ignored. + * <p> + * <p> + * Example: + * </p> * - * Two properties can be set: allowActorIdOverwrite & principalClassName. - * - * principalClassName configuration property - * specifies the class name of the principal that should be used from - * the current subject. This could be for example org.jboss.security.CallerIdentity - * in an JBoss AS. - * - * If not actorId is set, the name of that principal is used as the - * currently authenticated actorId. If an actorId!=null is set (via setActorId) - * this one overwrites the principal. This behavior is configurable via - * the allowActorIdOverwrite attribute. If this - * is set to false, setActorId is simply ignored. - * - * Example: - * &lt;service name="authentication"&gt; + * <pre> + * &lt;service name=&quot;authentication&quot;&gt; * &lt;factory&gt; - * &lt;bean class="org.jbpm.security.authentication.SubjectAuthenticationServiceFactory"&gt; - * &lt;field name="principalClassName"&gt; &lt;string value="org.jboss.security.CallerIdentity" /&gt; &lt;/field&gt; - * &lt;field name="allowActorIdOverwrite"&gt; &lt;boolean value="true" /&gt; &lt;/field&gt; + * &lt;bean class=&quot;org.jbpm.security.authentication.SubjectAuthenticationServiceFactory&quot;&gt; + * &lt;field name=&quot;principalClassName&quot;&gt; &lt;string value=&quot;org.jboss.security.CallerIdentity&quot; /&gt; &lt;/field&gt; + * &lt;field name=&quot;allowActorIdOverwrite&quot;&gt; &lt;boolean value=&quot;true&quot; /&gt; &lt;/field&gt; * &lt;/bean&gt; * &lt;/factory&gt; * &lt;/service&gt; + * </pre> * * @author bernd.ruecker(a)camunda.com */ public class SubjectAuthenticationServiceFactory implements ServiceFactory { private static final long serialVersionUID = 1L; - + private Boolean allowActorIdOverwrite; - + private String principalClassName; public Service openService() { @@ -67,23 +74,19 @@ public void close() { } - public boolean isAllowActorIdOverwrite() - { + public Boolean isAllowActorIdOverwrite() { return allowActorIdOverwrite; } - public void setAllowActorIdOverwrite(boolean allowActorIdOverwrite) - { + public void setAllowActorIdOverwrite(Boolean allowActorIdOverwrite) { this.allowActorIdOverwrite = allowActorIdOverwrite; } - public String getPrincipalClassName() - { + public String getPrincipalClassName() { return principalClassName; } - public void setPrincipalClassName(String principalClassName) - { + public void setPrincipalClassName(String principalClassName) { this.principalClassName = principalClassName; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/svc/Services.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/svc/Services.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/svc/Services.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -32,6 +32,8 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hibernate.StaleStateException; +import org.hibernate.exception.LockAcquisitionException; + import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.graph.exe.ProcessInstance; @@ -50,8 +52,8 @@ import org.jbpm.svc.save.SaveOperation; import org.jbpm.tx.TxService; -public class Services implements Serializable -{ +public class Services implements Serializable { + private static final long serialVersionUID = 1L; public static final String SERVICENAME_AUTHENTICATION = "authentication"; @@ -66,8 +68,7 @@ static final List defaultSaveOperations = createDefaultSaveOperations(); - private static List createDefaultSaveOperations() - { + private static List createDefaultSaveOperations() { SaveOperation[] operations = new SaveOperation[4]; operations[0] = new CheckUnpersistableVariablesOperation(); // first we save the runtime data (process instance) @@ -79,101 +80,81 @@ return Arrays.asList(operations); } - Map<String, ServiceFactory> serviceFactories; - Map<String, Service> services; + Map serviceFactories; + Map services; List serviceNames = null; List saveOperations = null; - public static Service getCurrentService(String name) - { + public static Service getCurrentService(String name) { return getCurrentService(name, true); } - public static Service getCurrentService(String name, boolean isRequired) - { + public static Service getCurrentService(String name, boolean isRequired) { Service service = null; JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext(); - if (jbpmContext != null) - { + if (jbpmContext != null) { service = jbpmContext.getServices().getService(name); } - if (isRequired && (service == null)) - { + if (isRequired && (service == null)) { throw new JbpmServiceException("service '" + name + "' unavailable"); } return service; } - public Services(Map serviceFactories) - { + public Services(Map serviceFactories) { this(serviceFactories, new ArrayList(serviceFactories.keySet()), null); } - public Services(Map serviceFactories, List serviceNames, List saveOperations) - { + public Services(Map serviceFactories, List serviceNames, List saveOperations) { this.serviceFactories = serviceFactories; this.serviceNames = serviceNames; this.saveOperations = saveOperations != null ? saveOperations : defaultSaveOperations; } - public void setSaveOperations(List saveOperations) - { - if (saveOperations == null) - { + public void setSaveOperations(List saveOperations) { + if (saveOperations == null) { throw new IllegalArgumentException("saveOperations cannot be null"); } this.saveOperations = saveOperations; } - public void addSaveOperation(SaveOperation saveOperation) - { - if (saveOperation == null) - { + public void addSaveOperation(SaveOperation saveOperation) { + if (saveOperation == null) { throw new IllegalArgumentException("saveOperation cannot be null"); } - if (saveOperations == defaultSaveOperations) - { + if (saveOperations == defaultSaveOperations) { saveOperations = new ArrayList(defaultSaveOperations); } saveOperations.add(saveOperation); } - public Map<String, ServiceFactory> getServiceFactories() - { - if (serviceFactories == null) - { - serviceFactories = new HashMap<String, ServiceFactory>(); + public Map getServiceFactories() { + if (serviceFactories == null) { + serviceFactories = new HashMap(); } return serviceFactories; } - public ServiceFactory getServiceFactory(String name) - { - return getServiceFactories().get(name); + public ServiceFactory getServiceFactory(String name) { + return (ServiceFactory) getServiceFactories().get(name); } - public boolean hasService(String name) - { + public boolean hasService(String name) { boolean hasService = false; - if (services != null) - { + if (services != null) { hasService = services.containsKey(name); } return hasService; } - public Service getService(String name) - { - if (services == null) - { - services = new HashMap<String, Service>(); + public Service getService(String name) { + if (services == null) { + services = new HashMap(); } - Service service = services.get(name); - if (service == null) - { + Service service = (Service) services.get(name); + if (service == null) { ServiceFactory serviceFactory = getServiceFactory(name); - if (serviceFactory != null) - { + if (serviceFactory != null) { service = serviceFactory.openService(); services.put(name, service); } @@ -181,176 +162,139 @@ return service; } - public void save(ProcessInstance processInstance, JbpmContext jbpmContext) - { + public void save(ProcessInstance processInstance, JbpmContext jbpmContext) { Iterator iter = saveOperations.iterator(); - if (log.isDebugEnabled()) - { - if (saveOperations == defaultSaveOperations) - { + if (log.isDebugEnabled()) { + if (saveOperations == defaultSaveOperations) { log.debug("executing default save operations"); } - else - { + else { log.debug("executing custom save operations"); } } - while (iter.hasNext()) - { - SaveOperation saveOperation = (SaveOperation)iter.next(); + while (iter.hasNext()) { + SaveOperation saveOperation = (SaveOperation) iter.next(); saveOperation.save(processInstance, jbpmContext); } } // services ///////////////////////////////////////////////////////////////// - public AuthenticationService getAuthenticationService() - { - return (AuthenticationService)getService(SERVICENAME_AUTHENTICATION); + public AuthenticationService getAuthenticationService() { + return (AuthenticationService) getService(SERVICENAME_AUTHENTICATION); } - public AuthorizationService getAuthorizationService() - { - return (AuthorizationService)getService(SERVICENAME_AUTHORIZATION); + public AuthorizationService getAuthorizationService() { + return (AuthorizationService) getService(SERVICENAME_AUTHORIZATION); } - public LoggingService getLoggingService() - { - return (LoggingService)getService(SERVICENAME_LOGGING); + public LoggingService getLoggingService() { + return (LoggingService) getService(SERVICENAME_LOGGING); } - public MessageService getMessageService() - { - return (MessageService)getService(SERVICENAME_MESSAGE); + public MessageService getMessageService() { + return (MessageService) getService(SERVICENAME_MESSAGE); } - public PersistenceService getPersistenceService() - { - return (PersistenceService)getService(SERVICENAME_PERSISTENCE); + public PersistenceService getPersistenceService() { + return (PersistenceService) getService(SERVICENAME_PERSISTENCE); } - public SchedulerService getSchedulerService() - { - return (SchedulerService)getService(SERVICENAME_SCHEDULER); + public SchedulerService getSchedulerService() { + return (SchedulerService) getService(SERVICENAME_SCHEDULER); } - public TxService getTxService() - { - return (TxService)getService(SERVICENAME_TX); + public TxService getTxService() { + return (TxService) getService(SERVICENAME_TX); } - public void setAuthenticationService(AuthenticationService authenticationService) - { + public void setAuthenticationService(AuthenticationService authenticationService) { services.put(SERVICENAME_AUTHENTICATION, authenticationService); } - public void setAuthorizationService(AuthorizationService authorizationService) - { + public void setAuthorizationService(AuthorizationService authorizationService) { services.put(SERVICENAME_AUTHORIZATION, authorizationService); } - public void setLoggingService(LoggingService loggingService) - { + public void setLoggingService(LoggingService loggingService) { services.put(SERVICENAME_LOGGING, loggingService); } - public void setMessageService(MessageService messageService) - { + public void setMessageService(MessageService messageService) { services.put(SERVICENAME_MESSAGE, messageService); } - public void setPersistenceService(PersistenceService persistenceService) - { + public void setPersistenceService(PersistenceService persistenceService) { services.put(SERVICENAME_PERSISTENCE, persistenceService); } - public void setSchedulerService(SchedulerService schedulerService) - { + public void setSchedulerService(SchedulerService schedulerService) { services.put(SERVICENAME_SCHEDULER, schedulerService); } - public void setTxService(TxService txService) - { + public void setTxService(TxService txService) { services.put(SERVICENAME_TX, txService); } - public void close() - { - if (services != null) - { + public void close() { + if (services != null) { Exception firstException = null; Iterator iter = serviceNames.iterator(); - while (iter.hasNext()) - { - String serviceName = (String)iter.next(); - Service service = (Service)services.get(serviceName); - if (service != null) - { - try - { + while (iter.hasNext()) { + String serviceName = (String) iter.next(); + Service service = (Service) services.get(serviceName); + if (service != null) { + try { log.debug("closing service '" + serviceName + "': " + service); service.close(); } - catch (JbpmPersistenceException e) - { + catch (JbpmPersistenceException e) { // if this is a stale state exception, the jbpm configuration has control over the logging - if (isCausedByStaleState(e)) - { - log.info("problem closing service '" + serviceName + "': optimistic locking failed"); - StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error("problem closing service '" + serviceName + "': optimistic locking failed", e); + if (isCausedByStaleState(e)) { + StaleObjectLogConfigurer.getStaleObjectExceptionsLog().error( + "problem closing service '" + serviceName + "': optimistic locking failed", e); } - else - { + else { log.error("problem closing service '" + serviceName + "'", e); } - if (firstException == null) - { + if (firstException == null) { firstException = e; } } - catch (Exception e) - { + catch (Exception e) { // NOTE that Error's are not caught because that might halt the JVM and mask the original Error. log.error("problem closing service '" + serviceName + "'", e); - if (firstException == null) - { + if (firstException == null) { firstException = e; } } } } - if (firstException != null) - { - if (firstException instanceof JbpmException) - { - throw (JbpmException)firstException; + if (firstException != null) { + if (firstException instanceof JbpmException) { + throw (JbpmException) firstException; } throw new JbpmException("problem closing services", firstException); } } } - public static boolean isCausedByStaleState(JbpmPersistenceException persistenceException) - { - for (Throwable cause = persistenceException.getCause(); cause != null; cause = cause.getCause()) - { - if (cause instanceof StaleStateException) + public static boolean isCausedByStaleState(JbpmPersistenceException persistenceException) { + for (Throwable cause = persistenceException.getCause(); cause != null; cause = cause.getCause()) { + if (cause instanceof StaleStateException || cause instanceof LockAcquisitionException) return true; } return false; } - public static void assignId(Object object) - { + public static void assignId(Object object) { JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext(); - if (jbpmContext != null) - { + if (jbpmContext != null) { // give this process instance an id Services services = jbpmContext.getServices(); - if (services.hasService(Services.SERVICENAME_PERSISTENCE)) - { + if (services.hasService(Services.SERVICENAME_PERSISTENCE)) { PersistenceService persistenceService = services.getPersistenceService(); persistenceService.assignId(object); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -31,31 +31,32 @@ public class PooledActor implements Serializable { private static final long serialVersionUID = 1L; - + long id = 0; int version = 0; protected String actorId = null; protected Set taskInstances = null; protected SwimlaneInstance swimlaneInstance = null; - public static Set<PooledActor> createPool(String[] actorIds, SwimlaneInstance swimlaneInstance, TaskInstance taskInstance) { - Set<PooledActor> pooledActors = new HashSet<PooledActor>(); - for (int i=0; i<actorIds.length; i++) { + public static Set createPool(String[] actorIds, SwimlaneInstance swimlaneInstance, + TaskInstance taskInstance) { + Set pooledActors = new HashSet(); + for (int i = 0; i < actorIds.length; i++) { PooledActor pooledActor = new PooledActor(actorIds[i]); - if (swimlaneInstance!=null) { + if (swimlaneInstance != null) { pooledActor.setSwimlaneInstance(swimlaneInstance); } - if (taskInstance!=null) { + if (taskInstance != null) { pooledActor.addTaskInstance(taskInstance); } pooledActors.add(pooledActor); } return pooledActors; } - + public static Set extractActorIds(Set poooledActors) { Set extractedActorIds = null; - if (poooledActors!=null) { + if (poooledActors != null) { extractedActorIds = new HashSet(); Iterator iter = poooledActors.iterator(); while (iter.hasNext()) { @@ -72,16 +73,18 @@ public PooledActor(String actorId) { this.actorId = actorId; } - + public void addTaskInstance(TaskInstance taskInstance) { - if (taskInstances==null) taskInstances = new HashSet(); + if (taskInstances == null) taskInstances = new HashSet(); taskInstances.add(taskInstance); } + public Set getTaskInstances() { return taskInstances; } + public void removeTaskInstance(TaskInstance taskInstance) { - if (taskInstances!=null) { + if (taskInstances != null) { taskInstances.remove(taskInstance); } } @@ -92,25 +95,29 @@ public boolean equals(Object o) { return EqualsUtil.equals(this, o); } - + public String toString() { - return "PooledActor("+actorId+")"; + return "PooledActor(" + actorId + ")"; } - + // getters and setters ////////////////////////////////////////////////////// public String getActorId() { return actorId; } + public void setActorId(String actorId) { this.actorId = actorId; } + public SwimlaneInstance getSwimlaneInstance() { return swimlaneInstance; } + public void setSwimlaneInstance(SwimlaneInstance swimlaneInstance) { this.swimlaneInstance = swimlaneInstance; } + public long getId() { return id; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,10 +21,10 @@ */ package org.jbpm.taskmgmt.exe; -import java.io.*; +import java.io.Serializable; import java.util.Set; -import org.jbpm.taskmgmt.def.*; +import org.jbpm.taskmgmt.def.Swimlane; import org.jbpm.util.EqualsUtil; /** @@ -38,13 +38,13 @@ int version = 0; protected String name = null; protected String actorId = null; - protected Set<PooledActor> pooledActors = null; + protected Set pooledActors = null; protected Swimlane swimlane = null; protected TaskMgmtInstance taskMgmtInstance = null; - + public SwimlaneInstance() { } - + public SwimlaneInstance(Swimlane swimlane) { this.name = swimlane.getName(); this.swimlane = swimlane; @@ -60,34 +60,42 @@ public boolean equals(Object o) { return EqualsUtil.equals(this, o); } - + // getters and setters ////////////////////////////////////////////////////// public long getId() { return id; } + public String getName() { return name; } + public Swimlane getSwimlane() { return swimlane; } + public String getActorId() { return actorId; } + public void setActorId(String actorId) { this.actorId = actorId; } + public TaskMgmtInstance getTaskMgmtInstance() { return taskMgmtInstance; } + public void setTaskMgmtInstance(TaskMgmtInstance taskMgmtInstance) { this.taskMgmtInstance = taskMgmtInstance; } - public Set<PooledActor> getPooledActors() { + + public Set getPooledActors() { return pooledActors; } - public void setPooledActors(Set<PooledActor> pooledActors) { + + public void setPooledActors(Set pooledActors) { this.pooledActors = pooledActors; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,6 +30,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmException; import org.jbpm.context.exe.ContextInstance; import org.jbpm.context.exe.VariableContainer; @@ -52,11 +53,10 @@ import org.jbpm.util.EqualsUtil; /** - * is one task instance that can be assigned to an actor (read: put in someones task list) and that can trigger the - * coninuation of execution of the token upon completion. + * is one task instance that can be assigned to an actor (read: put in someones task list) and that + * can trigger the coninuation of execution of the token upon completion. */ -public class TaskInstance extends VariableContainer implements Identifiable, Assignable -{ +public class TaskInstance extends VariableContainer implements Identifiable, Assignable { private static final long serialVersionUID = 1L; @@ -80,28 +80,24 @@ protected SwimlaneInstance swimlaneInstance = null; protected TaskMgmtInstance taskMgmtInstance = null; protected ProcessInstance processInstance = null; - protected Set<PooledActor> pooledActors = null; + protected Set pooledActors = null; protected List comments = null; protected String previousActorId = null; // not persisted. just extra information for listeners of the assign-event - public TaskInstance() - { + public TaskInstance() { } - public TaskInstance(String taskName) - { + public TaskInstance(String taskName) { this.name = taskName; } - public TaskInstance(String taskName, String actorId) - { + public TaskInstance(String taskName, String actorId) { this.name = taskName; this.actorId = actorId; } - public void setTask(Task task) - { + public void setTask(Task task) { this.name = task.getName(); this.description = task.getDescription(); this.task = task; @@ -110,60 +106,54 @@ this.isSignalling = task.isSignalling(); } - void submitVariables() - { + void submitVariables() { TaskController taskController = (task != null ? task.getTaskController() : null); // if there is a task controller, - if (taskController != null) - { + if (taskController != null) { // the task controller is responsible for copying variables back into the process taskController.submitParameters(this); // if there is no task controller } - else if ((token != null) && (token.getProcessInstance() != null)) - { + else if ((token != null) && (token.getProcessInstance() != null)) { // the default behaviour is that all task-local variables are flushed to the process - if (variableInstances != null) - { + if (variableInstances != null) { ContextInstance contextInstance = token.getProcessInstance().getContextInstance(); Iterator iter = variableInstances.values().iterator(); - while (iter.hasNext()) - { - VariableInstance variableInstance = (VariableInstance)iter.next(); - log.debug("flushing variable '" + variableInstance.getName() + "' from task '" + name + "' to process variables"); + while (iter.hasNext()) { + VariableInstance variableInstance = (VariableInstance) iter.next(); + log.debug("flushing variable '" + + variableInstance.getName() + + "' from task '" + + name + + "' to process variables"); // This might be optimized, but this was the simplest way to make a clone of the variable instance. - contextInstance.setVariable(variableInstance.getName(), variableInstance.getValue(), token); + contextInstance.setVariable(variableInstance.getName(), variableInstance.getValue(), + token); } } } } - void initializeVariables() - { + void initializeVariables() { TaskController taskController = (task != null ? task.getTaskController() : null); - if (taskController != null) - { + if (taskController != null) { taskController.initializeVariables(this); } } - public void create() - { + public void create() { create(null); } - public void create(ExecutionContext executionContext) - { - if (create != null) - { + public void create(ExecutionContext executionContext) { + if (create != null) { throw new IllegalStateException("task instance '" + id + "' was already created"); } create = Clock.getCurrentTime(); // if this task instance is associated with a task... - if ((task != null) && (executionContext != null)) - { + if ((task != null) && (executionContext != null)) { // the TASK_CREATE event is fired executionContext.setTaskInstance(this); executionContext.setTask(task); @@ -175,18 +165,15 @@ // See also: TaskMgmtInstance.createTaskInstance } - public void assign(ExecutionContext executionContext) - { + public void assign(ExecutionContext executionContext) { TaskMgmtInstance taskMgmtInstance = executionContext.getTaskMgmtInstance(); Swimlane swimlane = task.getSwimlane(); // if this task is in a swimlane - if (swimlane != null) - { + if (swimlane != null) { // if this is a task assignment for a start-state - if (isStartTaskInstance()) - { + if (isStartTaskInstance()) { // initialize the swimlane swimlaneInstance = new SwimlaneInstance(swimlane); taskMgmtInstance.addSwimlaneInstance(swimlaneInstance); @@ -194,44 +181,40 @@ swimlaneInstance.setActorId(SecurityHelper.getAuthenticatedActorId()); } - else - { + else { // lazy initialize the swimlane... // get the swimlane instance (if there is any) - swimlaneInstance = taskMgmtInstance.getInitializedSwimlaneInstance(executionContext, swimlane); + swimlaneInstance = taskMgmtInstance.getInitializedSwimlaneInstance(executionContext, + swimlane); // copy the swimlaneInstance assignment into the taskInstance assignment copySwimlaneInstanceAssignment(swimlaneInstance); } } - else - { // this task is not in a swimlane - taskMgmtInstance.performAssignment(task.getAssignmentDelegation(), task.getActorIdExpression(), task.getPooledActorsExpression(), this, executionContext); + else { // this task is not in a swimlane + taskMgmtInstance.performAssignment(task.getAssignmentDelegation(), + task.getActorIdExpression(), task.getPooledActorsExpression(), this, executionContext); } updatePooledActorsReferences(swimlaneInstance); } - public boolean isStartTaskInstance() - { + public boolean isStartTaskInstance() { boolean isStartTaskInstance = false; - if ((taskMgmtInstance != null) && (taskMgmtInstance.getTaskMgmtDefinition() != null)) - { - isStartTaskInstance = ((task != null) && (task.equals(taskMgmtInstance.getTaskMgmtDefinition().getStartTask()))); + if ((taskMgmtInstance != null) && (taskMgmtInstance.getTaskMgmtDefinition() != null)) { + isStartTaskInstance = ((task != null) && (task.equals(taskMgmtInstance.getTaskMgmtDefinition() + .getStartTask()))); } return isStartTaskInstance; } - void updatePooledActorsReferences(SwimlaneInstance swimlaneInstance) - { - if (pooledActors != null) - { + void updatePooledActorsReferences(SwimlaneInstance swimlaneInstance) { + if (pooledActors != null) { Iterator iter = pooledActors.iterator(); - while (iter.hasNext()) - { - PooledActor pooledActor = (PooledActor)iter.next(); + while (iter.hasNext()) { + PooledActor pooledActor = (PooledActor) iter.next(); pooledActor.setSwimlaneInstance(swimlaneInstance); pooledActor.addTaskInstance(this); } @@ -239,35 +222,31 @@ } /** - * copies the assignment (that includes both the swimlaneActorId and the set of pooledActors) of the given swimlane - * into this taskInstance. + * copies the assignment (that includes both the swimlaneActorId and the set of pooledActors) of + * the given swimlane into this taskInstance. */ - public void copySwimlaneInstanceAssignment(SwimlaneInstance swimlaneInstance) - { + public void copySwimlaneInstanceAssignment(SwimlaneInstance swimlaneInstance) { setSwimlaneInstance(swimlaneInstance); setActorId(swimlaneInstance.getActorId()); setPooledActors(swimlaneInstance.getPooledActors()); } /** - * gets the pool of actors for this task instance. If this task has a simlaneInstance and no pooled actors, the pooled - * actors of the swimlane instance are returned. + * gets the pool of actors for this task instance. If this task has a simlaneInstance and no + * pooled actors, the pooled actors of the swimlane instance are returned. */ - public Set<PooledActor> getPooledActors() - { - if ((swimlaneInstance != null) && ((pooledActors == null) || (pooledActors.isEmpty()))) - { + public Set getPooledActors() { + if (swimlaneInstance != null && (pooledActors == null || pooledActors.isEmpty())) { return swimlaneInstance.getPooledActors(); } return pooledActors; } /** - * (re)assign this task to the given actor. If this task is related to a swimlane instance, that swimlane instance - * will be updated as well. + * (re)assign this task to the given actor. If this task is related to a swimlane instance, that + * swimlane instance will be updated as well. */ - public void setActorId(String actorId) - { + public void setActorId(String actorId) { setActorId(actorId, true); } @@ -275,22 +254,20 @@ * (re)assign this task to the given actor. * * @param actorId is reference to the person that is assigned to this task. - * @param overwriteSwimlane specifies if the related swimlane should be overwritten with the given swimlaneActorId. + * @param overwriteSwimlane specifies if the related swimlane should be overwritten with the given + * swimlaneActorId. */ - public void setActorId(String actorId, boolean overwriteSwimlane) - { + public void setActorId(String actorId, boolean overwriteSwimlane) { // do the actual assignment this.previousActorId = this.actorId; this.actorId = actorId; - if ((swimlaneInstance != null) && (overwriteSwimlane)) - { + if ((swimlaneInstance != null) && (overwriteSwimlane)) { log.debug("assigning task '" + name + "' to '" + actorId + "'"); swimlaneInstance.setActorId(actorId); } // fire the event - if ((task != null) && (token != null)) - { + if ((task != null) && (token != null)) { ExecutionContext executionContext = new ExecutionContext(token); executionContext.setTask(task); executionContext.setTaskInstance(this); @@ -302,32 +279,27 @@ } // add the log - if (token != null) - { + if (token != null) { // log this assignment token.addLog(new TaskAssignLog(this, previousActorId, actorId)); } } /** takes a set of String's as the actorIds */ - public void setPooledActors(String[] actorIds) - { + public void setPooledActors(String[] actorIds) { this.pooledActors = PooledActor.createPool(actorIds, null, this); } /** * can optionally be used to indicate that the actor is starting to work on this task instance. */ - public void start() - { - if (start != null) - { + public void start() { + if (start != null) { throw new IllegalStateException("task instance '" + id + "' is already started"); } start = Clock.getCurrentTime(); - if ((task != null) && (token != null)) - { + if ((task != null) && (token != null)) { ExecutionContext executionContext = new ExecutionContext(token); executionContext.setTask(task); executionContext.setTaskInstance(this); @@ -338,16 +310,14 @@ /** * convenience method that combines a {@link #setActorId(String)} and a {@link #start()}. */ - public void start(String actorId) - { + public void start(String actorId) { start(actorId, true); } /** * convenience method that combines a {@link #setActorId(String,boolean)} and a {@link #start()}. */ - public void start(String actorId, boolean overwriteSwimlane) - { + public void start(String actorId, boolean overwriteSwimlane) { setActorId(actorId, overwriteSwimlane); start(); } @@ -355,101 +325,90 @@ /** * overwrite start date */ - public void setStart(Date date) - { + public void setStart(Date date) { start = null; } - private void markAsCancelled() - { + private void markAsCancelled() { this.isCancelled = true; this.isOpen = false; } /** - * cancels this task. This task intance will be marked as cancelled and as ended. But cancellation doesn't influence - * singalling and continuation of process execution. + * cancels this task. This task intance will be marked as cancelled and as ended. But cancellation + * doesn't influence singalling and continuation of process execution. */ - public void cancel() - { + public void cancel() { markAsCancelled(); end(); } /** - * cancels this task, takes the specified transition. This task intance will be marked as cancelled and as ended. But - * cancellation doesn't influence singalling and continuation of process execution. + * cancels this task, takes the specified transition. This task intance will be marked as + * cancelled and as ended. But cancellation doesn't influence singalling and continuation of + * process execution. */ - public void cancel(Transition transition) - { + public void cancel(Transition transition) { markAsCancelled(); end(transition); } /** - * cancels this task, takes the specified transition. This task intance will be marked as cancelled and as ended. But - * cancellation doesn't influence singalling and continuation of process execution. + * cancels this task, takes the specified transition. This task intance will be marked as + * cancelled and as ended. But cancellation doesn't influence singalling and continuation of + * process execution. */ - public void cancel(String transitionName) - { + public void cancel(String transitionName) { markAsCancelled(); end(transitionName); } /** - * marks this task as done. If this task is related to a task node this might trigger a signal on the token. + * marks this task as done. If this task is related to a task node this might trigger a signal on + * the token. * * @see #end(Transition) */ - public void end() - { - end((Transition)null); + public void end() { + end((Transition) null); } /** - * marks this task as done and specifies the name of a transition leaving the task-node for the case that the - * completion of this task instances triggers a signal on the token. If this task leads to a signal on the token, the - * given transition name will be used in the signal. If this task completion does not trigger execution to move on, - * the transitionName is ignored. + * marks this task as done and specifies the name of a transition leaving the task-node for the + * case that the completion of this task instances triggers a signal on the token. If this task + * leads to a signal on the token, the given transition name will be used in the signal. If this + * task completion does not trigger execution to move on, the transitionName is ignored. */ - public void end(String transitionName) - { + public void end(String transitionName) { Transition leavingTransition = null; - if (task != null) - { + if (task != null) { Node node = task.getTaskNode(); - if (node == null) - { - node = (Node)task.getParent(); + if (node == null) { + node = (Node) task.getParent(); } - if (node != null) - { + if (node != null) { leavingTransition = node.getLeavingTransition(transitionName); } } - if (leavingTransition == null) - { + if (leavingTransition == null) { throw new JbpmException("task node does not have leaving transition '" + transitionName + "'"); } end(leavingTransition); } /** - * marks this task as done and specifies a transition leaving the task-node for the case that the completion of this - * task instances triggers a signal on the token. If this task leads to a signal on the token, the given transition - * name will be used in the signal. If this task completion does not trigger execution to move on, the transition is - * ignored. + * marks this task as done and specifies a transition leaving the task-node for the case that the + * completion of this task instances triggers a signal on the token. If this task leads to a + * signal on the token, the given transition name will be used in the signal. If this task + * completion does not trigger execution to move on, the transition is ignored. */ - public void end(Transition transition) - { - if (this.end != null) - { + public void end(Transition transition) { + if (this.end != null) { throw new IllegalStateException("task instance '" + id + "' is already ended"); } - if (this.isSuspended) - { + if (this.isSuspended) { throw new JbpmException("task instance '" + id + "' is suspended"); } @@ -458,8 +417,7 @@ this.isOpen = false; // fire the task instance end event - if ((task != null) && (token != null)) - { + if ((task != null) && (token != null)) { ExecutionContext executionContext = new ExecutionContext(token); executionContext.setTask(task); executionContext.setTaskInstance(this); @@ -467,8 +425,7 @@ } // log this assignment - if (token != null) - { + if (token != null) { token.addLog(new TaskEndLog(this)); } @@ -476,40 +433,39 @@ submitVariables(); // verify if the end of this task triggers continuation of execution - if (isSignalling) - { + if (isSignalling) { this.isSignalling = false; if (this.isStartTaskInstance() // ending start tasks always leads to a signal - || ((task != null) && (token != null) && (task.getTaskNode() != null) && (task.getTaskNode().completionTriggersSignal(this)))) - { + || ((task != null) && (token != null) && (task.getTaskNode() != null) && (task.getTaskNode().completionTriggersSignal(this)))) { - if (transition == null) - { - log.debug("completion of task '" + task.getName() + "' results in taking the default transition"); + if (transition == null) { + log.debug("completion of task '" + + task.getName() + + "' results in taking the default transition"); token.signal(); } - else - { - log.debug("completion of task '" + task.getName() + "' results in taking transition '" + transition + "'"); + else { + log.debug("completion of task '" + + task.getName() + + "' results in taking transition '" + + transition + + "'"); token.signal(transition); } } } } - public boolean hasEnded() - { + public boolean hasEnded() { return (end != null); } /** * suspends a process execution. */ - public void suspend() - { - if (!isOpen) - { + public void suspend() { + if (!isOpen) { throw new JbpmException("a task that is not open cannot be suspended: " + toString()); } isSuspended = true; @@ -518,10 +474,8 @@ /** * resumes a process execution. */ - public void resume() - { - if (!isOpen) - { + public void resume() { + if (!isOpen) { throw new JbpmException("a task that is not open cannot be resumed: " + toString()); } isSuspended = false; @@ -529,48 +483,39 @@ // comments ///////////////////////////////////////////////////////////////// - public void addComment(String message) - { + public void addComment(String message) { addComment(new Comment(message)); } - public void addComment(Comment comment) - { - if (comment != null) - { - if (comments == null) - comments = new ArrayList(); + public void addComment(Comment comment) { + if (comment != null) { + if (comments == null) comments = new ArrayList(); comments.add(comment); comment.setTaskInstance(this); - if (token != null) - { + if (token != null) { comment.setToken(token); token.addComment(comment); } } } - public List getComments() - { + public List getComments() { return comments; } // task form //////////////////////////////////////////////////////////////// - public boolean isLast() - { + public boolean isLast() { return ((token != null) && (taskMgmtInstance != null) && (!taskMgmtInstance.hasUnfinishedTasks(token))); } /** - * is the list of transitions that can be used in the end method and it is null in case this is not the last task - * instance. + * is the list of transitions that can be used in the end method and it is null in case this is + * not the last task instance. */ - public List getAvailableTransitions() - { + public List getAvailableTransitions() { List transitions = null; - if ((!isLast()) && (token != null)) - { + if ((!isLast()) && (token != null)) { transitions = new ArrayList(token.getAvailableTransitions()); } return transitions; @@ -579,209 +524,170 @@ // 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); } - public String toString() - { - return "TaskInstance" + (name != null ? "(" + name + ")" : "@" + Integer.toHexString(hashCode())); + public String toString() { + return "TaskInstance" + + (name != null ? "(" + name + ")" : "@" + Integer.toHexString(hashCode())); } // private ////////////////////////////////////////////////////////////////// /** takes a set of {@link PooledActor}s */ - public void setPooledActors(Set pooledActors) - { - if (pooledActors != null) - { + public void setPooledActors(Set pooledActors) { + if (pooledActors != null) { this.pooledActors = new HashSet(pooledActors); Iterator iter = pooledActors.iterator(); - while (iter.hasNext()) - { - PooledActor pooledActor = (PooledActor)iter.next(); + while (iter.hasNext()) { + PooledActor pooledActor = (PooledActor) iter.next(); pooledActor.addTaskInstance(this); } } - else - { + else { this.pooledActors = null; } } // protected //////////////////////////////////////////////////////////////// - protected VariableContainer getParentVariableContainer() - { + protected VariableContainer getParentVariableContainer() { ContextInstance contextInstance = getContextInstance(); return (contextInstance != null ? contextInstance.getOrCreateTokenVariableMap(token) : null); } // getters and setters ////////////////////////////////////////////////////// - public String getActorId() - { + public String getActorId() { return actorId; } - public Date getDueDate() - { + public Date getDueDate() { return dueDate; } - public void setDueDate(Date dueDate) - { + public void setDueDate(Date dueDate) { this.dueDate = dueDate; } - public Date getEnd() - { + public Date getEnd() { return end; } - public void setEnd(Date end) - { + public void setEnd(Date end) { this.end = end; } - public void setCreate(Date create) - { + public void setCreate(Date create) { this.create = create; } - public long getId() - { + public long getId() { return id; } - public void setId(long id) - { + public void setId(long id) { this.id = id; } - public Date getStart() - { + public Date getStart() { return start; } - public TaskMgmtInstance getTaskMgmtInstance() - { + public TaskMgmtInstance getTaskMgmtInstance() { return taskMgmtInstance; } - public void setTaskMgmtInstance(TaskMgmtInstance taskMgmtInstance) - { + public void setTaskMgmtInstance(TaskMgmtInstance taskMgmtInstance) { this.taskMgmtInstance = taskMgmtInstance; } - public Token getToken() - { + public Token getToken() { return token; } - public void setToken(Token token) - { + public void setToken(Token token) { this.token = token; } - public void setSignalling(boolean isSignalling) - { + public void setSignalling(boolean isSignalling) { this.isSignalling = isSignalling; } - public boolean isSignalling() - { + public boolean isSignalling() { return isSignalling; } - public boolean isCancelled() - { + public boolean isCancelled() { return isCancelled; } - public String getName() - { + public String getName() { return name; } - public void setName(String name) - { + public void setName(String name) { this.name = name; } - public boolean isBlocking() - { + public boolean isBlocking() { return isBlocking; } - public void setBlocking(boolean isBlocking) - { + public void setBlocking(boolean isBlocking) { this.isBlocking = isBlocking; } - public Date getCreate() - { + public Date getCreate() { return create; } - public Task getTask() - { + public Task getTask() { return task; } - public SwimlaneInstance getSwimlaneInstance() - { + public SwimlaneInstance getSwimlaneInstance() { return swimlaneInstance; } - public void setSwimlaneInstance(SwimlaneInstance swimlaneInstance) - { + public void setSwimlaneInstance(SwimlaneInstance swimlaneInstance) { this.swimlaneInstance = swimlaneInstance; } - public String getPreviousActorId() - { + public String getPreviousActorId() { return previousActorId; } - public int getPriority() - { + public int getPriority() { return priority; } - public void setPriority(int priority) - { + public void setPriority(int priority) { this.priority = priority; } - public boolean isOpen() - { + public boolean isOpen() { return isOpen; } - public String getDescription() - { + public String getDescription() { return description; } - public void setDescription(String description) - { + public void setDescription(String description) { this.description = description; } - public boolean isSuspended() - { + public boolean isSuspended() { return isSuspended; } - public ProcessInstance getProcessInstance() - { + public ProcessInstance getProcessInstance() { return processInstance; } - public void setProcessInstance(ProcessInstance processInstance) - { + public void setProcessInstance(ProcessInstance processInstance) { this.processInstance = processInstance; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,7 +21,6 @@ */ package org.jbpm.taskmgmt.exe; -import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; @@ -59,50 +58,44 @@ /** * process instance extension for managing tasks on a process instance. */ -public class TaskMgmtInstance extends ModuleInstance -{ +public class TaskMgmtInstance extends ModuleInstance { private static final long serialVersionUID = 1L; TaskMgmtDefinition taskMgmtDefinition = null; - Map<String, SwimlaneInstance> swimlaneInstances = null; - Set<TaskInstance> taskInstances = null; + Map swimlaneInstances = null; + Set taskInstances = null; + /** * non persistent collection that stores all the task instances that have variable updates */ - Collection<TaskInstance> taskInstanceVariableUpdates = null; + Collection taskInstanceVariableUpdates = null; - public TaskMgmtInstance() - { + public TaskMgmtInstance() { } - public TaskMgmtInstance(TaskMgmtDefinition taskMgmtDefinition) - { + public TaskMgmtInstance(TaskMgmtDefinition taskMgmtDefinition) { this.taskMgmtDefinition = taskMgmtDefinition; } // task instances /////////////////////////////////////////////////////////// - public TaskInstance createTaskInstance() - { - return createTaskInstance(null, (ExecutionContext)null); + public TaskInstance createTaskInstance() { + return createTaskInstance(null, (ExecutionContext) null); } - public TaskInstance createTaskInstance(Task task) - { - return createTaskInstance(task, (ExecutionContext)null); + public TaskInstance createTaskInstance(Task task) { + return createTaskInstance(task, (ExecutionContext) null); } - public TaskInstance createTaskInstance(Token token) - { + public TaskInstance createTaskInstance(Token token) { return createTaskInstance(null, new ExecutionContext(token)); } /** * creates a new task instance on the given token, for the given task. */ - public TaskInstance createTaskInstance(Task task, Token token) - { + public TaskInstance createTaskInstance(Task task, Token token) { ExecutionContext executionContext = new ExecutionContext(token); executionContext.setTask(task); return createTaskInstance(task, executionContext); @@ -111,8 +104,7 @@ /** * creates a new task instance on the given task, in the given execution context. */ - public TaskInstance createTaskInstance(Task task, ExecutionContext executionContext) - { + public TaskInstance createTaskInstance(Task task, ExecutionContext executionContext) { // instantiate the new task instance TaskInstance taskInstance = instantiateNewTaskInstance(executionContext); @@ -120,95 +112,75 @@ addTaskInstance(taskInstance); // initialize the task instance - if (task != null) - taskInstance.setTask(task); + if (task != null) taskInstance.setTask(task); // assign an id to the task instance Services.assignId(taskInstance); - // copy the task properties - /* - * XXX property initialization was already done in taskInstance.setTask(task) String description = null; if - * (task!=null) { description = task.getDescription(); taskInstance.setDescription(description); - * taskInstance.setBlocking(task.isBlocking()); taskInstance.setSignalling(task.isSignalling()); } - */ - - if (executionContext != null) - { + if (executionContext != null) { Token token = executionContext.getToken(); taskInstance.setToken(token); taskInstance.setProcessInstance(token.getProcessInstance()); taskInstance.initializeVariables(); - if (task != null && task.getDueDate() != null) - { + if (task != null && task.getDueDate() != null) { Date baseDate; String dueDateString = task.getDueDate(); String durationString = null; - if (dueDateString.startsWith("#")) - { + if (dueDateString.startsWith("#")) { String baseDateEL = dueDateString.substring(0, dueDateString.indexOf("}") + 1); Object result = JbpmExpressionEvaluator.evaluate(baseDateEL, executionContext); - if (result instanceof Date) - { - baseDate = (Date)result; + if (result instanceof Date) { + baseDate = (Date) result; } - else if (result instanceof Calendar) - { - baseDate = ((Calendar)result).getTime(); + else if (result instanceof Calendar) { + baseDate = ((Calendar) result).getTime(); } - else - { - throw new JbpmException("Invalid basedate type: " + baseDateEL + " is of type " + result.getClass().getName() + else { + throw new JbpmException("Invalid basedate type: " + + baseDateEL + + " is of type " + + result.getClass().getName() + ". Only Date and Calendar are supported"); } int endOfELIndex = dueDateString.indexOf("}"); - if (endOfELIndex < (dueDateString.length() - 1)) - { + if (endOfELIndex < (dueDateString.length() - 1)) { char durationSeparator = dueDateString.substring(endOfELIndex + 1).trim().charAt(0); - if (durationSeparator != '+' && durationSeparator != '-') - { + if (durationSeparator != '+' && durationSeparator != '-') { throw new JbpmException("Invalid duedate, + or - missing after EL"); } durationString = dueDateString.substring(endOfELIndex + 1).trim(); } } - else - { + else { baseDate = Clock.getCurrentTime(); durationString = dueDateString; } Date dueDate; - if (durationString == null || durationString.length() == 0) - { + if (durationString == null || durationString.length() == 0) { dueDate = baseDate; } - else - { + else { BusinessCalendar businessCalendar = new BusinessCalendar(); dueDate = businessCalendar.add(baseDate, new Duration(durationString)); } taskInstance.setDueDate(dueDate); } - try - { + try { // update the executionContext executionContext.setTask(task); executionContext.setTaskInstance(taskInstance); executionContext.setEventSource(task); // evaluate the description - if (task != null) - { + if (task != null) { String description = task.getDescription(); - if ((description != null) && (description.indexOf("#{") != -1)) - { + if ((description != null) && (description.indexOf("#{") != -1)) { Object result = JbpmExpressionEvaluator.evaluate(description, executionContext); - if (result != null) - { + if (result != null) { taskInstance.setDescription(result.toString()); } } @@ -218,14 +190,11 @@ taskInstance.create(executionContext); // if this task instance is created for a task, perform assignment - if (task != null) - { + if (task != null) { taskInstance.assign(executionContext); } - } - finally - { + finally { // clean the executionContext executionContext.setTask(null); executionContext.setTaskInstance(null); @@ -236,152 +205,136 @@ // WARNING: The events create and assign are fired in the right order, but // the logs are still not ordered properly. token.addLog(new TaskCreateLog(taskInstance, taskInstance.getActorId())); - } - else - { + else { taskInstance.create(); } - return taskInstance; } - public SwimlaneInstance getInitializedSwimlaneInstance(ExecutionContext executionContext, Swimlane swimlane) - { + public SwimlaneInstance getInitializedSwimlaneInstance(ExecutionContext executionContext, + Swimlane swimlane) { // initialize the swimlane - if (swimlaneInstances == null) - swimlaneInstances = new HashMap<String, SwimlaneInstance>(); - SwimlaneInstance swimlaneInstance = swimlaneInstances.get(swimlane.getName()); - if (swimlaneInstance == null) - { + if (swimlaneInstances == null) swimlaneInstances = new HashMap(); + SwimlaneInstance swimlaneInstance = (SwimlaneInstance) swimlaneInstances.get(swimlane.getName()); + if (swimlaneInstance == null) { swimlaneInstance = new SwimlaneInstance(swimlane); addSwimlaneInstance(swimlaneInstance); // assign the swimlaneInstance - performAssignment(swimlane.getAssignmentDelegation(), swimlane.getActorIdExpression(), swimlane.getPooledActorsExpression(), swimlaneInstance, - executionContext); + performAssignment(swimlane.getAssignmentDelegation(), swimlane.getActorIdExpression(), + swimlane.getPooledActorsExpression(), swimlaneInstance, executionContext); } return swimlaneInstance; } - public void performAssignment(Delegation assignmentDelegation, String actorIdExpression, String pooledActorsExpression, Assignable assignable, - ExecutionContext executionContext) - { - try - { - if (assignmentDelegation != null) - { + public void performAssignment(Delegation assignmentDelegation, String actorIdExpression, + String pooledActorsExpression, Assignable assignable, ExecutionContext executionContext) { + try { + if (assignmentDelegation != null) { performAssignmentDelegation(assignmentDelegation, assignable, executionContext); } - else - { - if (actorIdExpression != null) - { + else { + if (actorIdExpression != null) { performAssignmentActorIdExpr(actorIdExpression, assignable, executionContext); } - if (pooledActorsExpression != null) - { + if (pooledActorsExpression != null) { performAssignmentPooledActorsExpr(pooledActorsExpression, assignable, executionContext); } } } - catch (Exception exception) - { + catch (Exception exception) { GraphElement graphElement = executionContext.getEventSource(); - if (graphElement != null) - { + if (graphElement != null) { graphElement.raiseException(exception, executionContext); } - else - { + else { throw new DelegationException(exception, executionContext); } } } - void performAssignmentDelegation(Delegation assignmentDelegation, Assignable assignable, ExecutionContext executionContext) throws Exception - { + void performAssignmentDelegation(Delegation assignmentDelegation, Assignable assignable, + ExecutionContext executionContext) throws Exception { ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader(); - try - { + try { // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448) - Thread.currentThread().setContextClassLoader(JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); + Thread.currentThread().setContextClassLoader( + JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition())); // instantiate the assignment handler - AssignmentHandler assignmentHandler = (AssignmentHandler)assignmentDelegation.instantiate(); + AssignmentHandler assignmentHandler = (AssignmentHandler) assignmentDelegation.instantiate(); // invoke the assignment handler - if (UserCodeInterceptorConfig.userCodeInterceptor != null) - { - UserCodeInterceptorConfig.userCodeInterceptor.executeAssignment(assignmentHandler, assignable, executionContext); + if (UserCodeInterceptorConfig.userCodeInterceptor != null) { + UserCodeInterceptorConfig.userCodeInterceptor.executeAssignment(assignmentHandler, + assignable, executionContext); } - else - { + else { assignmentHandler.assign(assignable, executionContext); } - } - finally - { + finally { Thread.currentThread().setContextClassLoader(surroundingClassLoader); } } - void performAssignmentActorIdExpr(String actorIdExpression, Assignable assignable, ExecutionContext executionContext) - { + void performAssignmentActorIdExpr(String actorIdExpression, Assignable assignable, + ExecutionContext executionContext) { Object result = null; String actorId = null; - try - { + try { result = JbpmExpressionEvaluator.evaluate(actorIdExpression, executionContext); - if (result == null) - { + if (result == null) { throw new JbpmException("actor-id expression '" + actorIdExpression + "' returned null"); } - actorId = (String)result; + actorId = (String) result; } - catch (ClassCastException e) - { - throw new JbpmException("actor-id expression '" + actorIdExpression + "' didn't resolve to a java.lang.String: '" + result + "' (" - + result.getClass().getName() + ")"); + catch (ClassCastException e) { + throw new JbpmException("actor-id expression '" + + actorIdExpression + + "' didn't resolve to a java.lang.String: '" + + result + + "' (" + + result.getClass().getName() + + ")"); } assignable.setActorId(actorId); } - void performAssignmentPooledActorsExpr(String pooledActorsExpression, Assignable assignable, ExecutionContext executionContext) - { + void performAssignmentPooledActorsExpr(String pooledActorsExpression, Assignable assignable, + ExecutionContext executionContext) { String[] pooledActors = null; Object result = JbpmExpressionEvaluator.evaluate(pooledActorsExpression, executionContext); - if (result == null) - { - throw new JbpmException("pooled-actors expression '" + pooledActorsExpression + "' returned null"); + if (result == null) { + throw new JbpmException("pooled-actors expression '" + + pooledActorsExpression + + "' returned null"); } - if (result instanceof String[]) - { - pooledActors = (String[])result; - + if (result instanceof String[]) { + pooledActors = (String[]) result; } - else if (result instanceof Collection) - { - Collection collection = (Collection)result; - pooledActors = (String[])collection.toArray(new String[collection.size()]); - + else if (result instanceof Collection) { + Collection collection = (Collection) result; + pooledActors = (String[]) collection.toArray(new String[collection.size()]); } - else if (result instanceof String) - { + else if (result instanceof String) { List pooledActorList = new ArrayList(); - StringTokenizer tokenizer = new StringTokenizer((String)result, ","); - while (tokenizer.hasMoreTokens()) - { + StringTokenizer tokenizer = new StringTokenizer((String) result, ","); + while (tokenizer.hasMoreTokens()) { pooledActorList.add(tokenizer.nextToken().trim()); } - pooledActors = (String[])pooledActorList.toArray(new String[pooledActorList.size()]); + pooledActors = (String[]) pooledActorList.toArray(new String[pooledActorList.size()]); } - else - { - throw new JbpmException("pooled-actors expression '" + pooledActorsExpression + "' didn't resolve to a comma separated String, a Collection or a String[]: '" - + result + "' (" + result.getClass().getName() + ")"); + else { + throw new JbpmException("pooled-actors expression '" + + pooledActorsExpression + + "' didn't resolve to a comma separated String, a Collection or a String[]: '" + + result + + "' (" + + result.getClass().getName() + + ")"); } assignable.setPooledActors(pooledActors); @@ -390,12 +343,10 @@ /** * creates a task instance on the rootToken, and assigns it to the currently authenticated user. */ - public TaskInstance createStartTaskInstance() - { + public TaskInstance createStartTaskInstance() { TaskInstance taskInstance = null; Task startTask = taskMgmtDefinition.getStartTask(); - if (startTask != null) - { + if (startTask != null) { Token rootToken = processInstance.getRootToken(); ExecutionContext executionContext = new ExecutionContext(rootToken); taskInstance = createTaskInstance(startTask, executionContext); @@ -404,59 +355,49 @@ return taskInstance; } - TaskInstance instantiateNewTaskInstance(ExecutionContext executionContext) - { - TaskInstanceFactory taskInstanceFactory = (TaskInstanceFactory)JbpmConfiguration.Configs.getObject("jbpm.task.instance.factory"); - if (taskInstanceFactory == null) - { + TaskInstance instantiateNewTaskInstance(ExecutionContext executionContext) { + TaskInstanceFactory taskInstanceFactory = (TaskInstanceFactory) JbpmConfiguration.Configs.getObject("jbpm.task.instance.factory"); + if (taskInstanceFactory == null) { throw new JbpmException("jbpm.task.instance.factory was not configured in jbpm.cfg.xml"); } return taskInstanceFactory.createTaskInstance(executionContext); } /** - * is true if the given token has task instances that keep the token from leaving the current node. + * is true if the given token has task instances that keep the token from leaving the current + * node. */ - public boolean hasBlockingTaskInstances(Token token) - { - boolean hasBlockingTasks = false; - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext() && !hasBlockingTasks) - { - TaskInstance taskInstance = iter.next(); - if ((!taskInstance.hasEnded()) && (taskInstance.isBlocking()) && (token != null) && (token.equals(taskInstance.getToken()))) - { - hasBlockingTasks = true; + public boolean hasBlockingTaskInstances(Token token) { + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if (!taskInstance.hasEnded() + && taskInstance.isBlocking() + && token != null + && token.equals(taskInstance.getToken())) { + return true; } } } - return hasBlockingTasks; + return false; } /** * is true if the given token has task instances that are not yet ended. */ - public boolean hasUnfinishedTasks(Token token) - { + public boolean hasUnfinishedTasks(Token token) { return (getUnfinishedTasks(token).size() > 0); } /** * is the collection of {@link TaskInstance}s on the given token that are not ended. */ - public Collection<TaskInstance> getUnfinishedTasks(Token token) - { - Collection<TaskInstance> unfinishedTasks = new ArrayList<TaskInstance>(); - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance task = iter.next(); - if ((!task.hasEnded()) && (token != null) && (token.equals(task.getToken()))) - { + public Collection getUnfinishedTasks(Token token) { + Collection unfinishedTasks = new ArrayList(); + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance task = (TaskInstance) i.next(); + if (!task.hasEnded() && token != null && token.equals(task.getToken())) { unfinishedTasks.add(task); } } @@ -465,27 +406,24 @@ } /** - * is true if there are {@link TaskInstance}s on the given token that can trigger the token to continue. + * is true if there are {@link TaskInstance}s on the given token that can trigger the token to + * continue. */ - public boolean hasSignallingTasks(ExecutionContext executionContext) - { + public boolean hasSignallingTasks(ExecutionContext executionContext) { return (getSignallingTasks(executionContext).size() > 0); } /** - * is the collection of {@link TaskInstance}s for the given token that can trigger the token to continue. + * is the collection of {@link TaskInstance}s for the given token that can trigger the token to + * continue. */ - public Collection<TaskInstance> getSignallingTasks(ExecutionContext executionContext) - { - Collection<TaskInstance> signallingTasks = new ArrayList<TaskInstance>(); - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance taskInstance = iter.next(); - if (taskInstance.isSignalling() && (executionContext.getToken().equals(taskInstance.getToken()))) - { + public Collection getSignallingTasks(ExecutionContext executionContext) { + Collection signallingTasks = new ArrayList(); + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if (taskInstance.isSignalling() + && (executionContext.getToken().equals(taskInstance.getToken()))) { signallingTasks.add(taskInstance); } } @@ -494,106 +432,79 @@ } /** - * returns all the taskInstances for the this process instance. This includes task instances that have been completed - * previously. + * returns all the taskInstances for the this process instance. This includes task instances that + * have been completed previously. */ - public Collection<TaskInstance> getTaskInstances() - { + public Collection getTaskInstances() { return taskInstances; } - public void addTaskInstance(TaskInstance taskInstance) - { - if (taskInstances == null) - taskInstances = new HashSet<TaskInstance>(); + public void addTaskInstance(TaskInstance taskInstance) { + if (taskInstances == null) taskInstances = new HashSet(); taskInstances.add(taskInstance); taskInstance.setTaskMgmtInstance(this); } - public void removeTaskInstance(TaskInstance taskInstance) - { - if (taskInstances != null) - { + public void removeTaskInstance(TaskInstance taskInstance) { + if (taskInstances != null) { taskInstances.remove(taskInstance); } } // swimlane instances /////////////////////////////////////////////////////// - public Map<String, SwimlaneInstance> getSwimlaneInstances() - { + public Map getSwimlaneInstances() { return swimlaneInstances; } - public void addSwimlaneInstance(SwimlaneInstance swimlaneInstance) - { - if (swimlaneInstances == null) - swimlaneInstances = new HashMap<String, SwimlaneInstance>(); + public void addSwimlaneInstance(SwimlaneInstance swimlaneInstance) { + if (swimlaneInstances == null) swimlaneInstances = new HashMap(); swimlaneInstances.put(swimlaneInstance.getName(), swimlaneInstance); swimlaneInstance.setTaskMgmtInstance(this); } - public SwimlaneInstance getSwimlaneInstance(String swimlaneName) - { - return swimlaneInstances != null ? swimlaneInstances.get(swimlaneName) : null; + public SwimlaneInstance getSwimlaneInstance(String swimlaneName) { + return swimlaneInstances != null ? (SwimlaneInstance) swimlaneInstances.get(swimlaneName) + : null; } - public SwimlaneInstance createSwimlaneInstance(String swimlaneName) - { - Swimlane swimlane = (taskMgmtDefinition != null ? taskMgmtDefinition.getSwimlane(swimlaneName) : null); - if (swimlane != null) - { + public SwimlaneInstance createSwimlaneInstance(String swimlaneName) { + Swimlane swimlane = (taskMgmtDefinition != null ? taskMgmtDefinition.getSwimlane(swimlaneName) + : null); + if (swimlane != null) { return createSwimlaneInstance(swimlane); } - throw new JbpmException("couldn't create swimlane instance for non-existing swimlane " + swimlaneName); + throw new JbpmException("couldn't create swimlane instance for non-existing swimlane " + + swimlaneName); } - public SwimlaneInstance createSwimlaneInstance(Swimlane swimlane) - { - if (swimlaneInstances == null) - swimlaneInstances = new HashMap<String, SwimlaneInstance>(); - SwimlaneInstance swimlaneInstance = new SwimlaneInstance(swimlane); - try - { - swimlaneInstance.setTaskMgmtInstance(this); - Class<?> persistentMapClass = swimlaneInstances.getClass(); - Field mapField = persistentMapClass.getDeclaredField("map"); - mapField.setAccessible(true); - // TODO remove the size when we switch to hibernate 3.2.1 (it's a workaround for a bug) - swimlaneInstances.size(); - swimlaneInstances.put(swimlaneInstance.getName(), swimlaneInstance); + public SwimlaneInstance createSwimlaneInstance(Swimlane swimlane) { + if (swimlaneInstances == null) { + swimlaneInstances = new HashMap(); } - catch (Exception e) - { - e.printStackTrace(); - } + SwimlaneInstance swimlaneInstance = new SwimlaneInstance(swimlane); + swimlaneInstance.setTaskMgmtInstance(this); + swimlaneInstances.put(swimlaneInstance.getName(), swimlaneInstance); return swimlaneInstance; } // getters and setters ////////////////////////////////////////////////////// - public TaskMgmtDefinition getTaskMgmtDefinition() - { + public TaskMgmtDefinition getTaskMgmtDefinition() { return taskMgmtDefinition; } /** * suspends all task instances for this process instance. */ - public void suspend(Token token) - { - if (token == null) - { + public void suspend(Token token) { + if (token == null) { throw new JbpmException("can't suspend task instances for token null"); } - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance taskInstance = iter.next(); - if ((token.equals(taskInstance.getToken())) && (taskInstance.isOpen())) - { + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if ((token.equals(taskInstance.getToken())) && (taskInstance.isOpen())) { taskInstance.suspend(); } } @@ -603,31 +514,23 @@ /** * resumes all task instances for this process instance. */ - public void resume(Token token) - { - if (token == null) - { + public void resume(Token token) { + if (token == null) { throw new JbpmException("can't suspend task instances for token null"); } - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance taskInstance = iter.next(); - if ((token.equals(taskInstance.getToken())) && (taskInstance.isOpen())) - { + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if ((token.equals(taskInstance.getToken())) && (taskInstance.isOpen())) { taskInstance.resume(); } } } } - void notifyVariableUpdate(TaskInstance taskInstance) - { - if (taskInstanceVariableUpdates == null) - { - taskInstanceVariableUpdates = new HashSet<TaskInstance>(); + void notifyVariableUpdate(TaskInstance taskInstance) { + if (taskInstanceVariableUpdates == null) { + taskInstanceVariableUpdates = new HashSet(); } taskInstanceVariableUpdates.add(taskInstance); } @@ -635,24 +538,18 @@ /** * returns the collection of task instance with variable updates. */ - public Collection<TaskInstance> getTaskInstancesWithVariableUpdates() - { + public Collection getTaskInstancesWithVariableUpdates() { return taskInstanceVariableUpdates; } /** * convenience method to end all tasks related to a given process instance. */ - public void endAll() - { - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance taskInstance = iter.next(); - if (!taskInstance.hasEnded()) - { + public void endAll() { + if (taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if (!taskInstance.hasEnded()) { taskInstance.end(); } } @@ -662,16 +559,11 @@ /** * removes signalling capabilities from all task instances related to the given token. */ - public void removeSignalling(Token token) - { - if (taskInstances != null) - { - Iterator<TaskInstance> iter = taskInstances.iterator(); - while (iter.hasNext()) - { - TaskInstance taskInstance = iter.next(); - if ((token != null) && (token.equals(taskInstance.getToken()))) - { + public void removeSignalling(Token token) { + if (token != null && taskInstances != null) { + for (Iterator i = taskInstances.iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); + if (token.equals(taskInstance.getToken())) { taskInstance.setSignalling(false); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,32 +21,76 @@ */ package org.jbpm.util; +/** + * Various methods for manipulating arrays. + */ public class ArrayUtil { private ArrayUtil() { // hide default constructor to prevent instantiation } - public static String toString(Object[] array) { - if (array==null) { - return "null"; - } else { - StringBuffer buffer = new StringBuffer(); - buffer.append("<["); - for (int i=0; i<array.length; i++) { - Object o = array[i]; - if (o!=null) { - buffer.append(o); - } else { - buffer.append("null"); - } - if (i!=array.length-1) { - buffer.append("|"); - } - } - buffer.append("]>"); - return buffer.toString(); + /** + * Returns a string representation of the contents of the specified array. If the array contains + * other arrays as elements, they are converted to strings by the {@link Object#toString} method + * inherited from <tt>Object</tt>, which describes their <i>identities</i> rather than their + * contents. + * <p> + * The value returned by this method is equal to the value that would be returned by + * <tt>Arrays.asList(a).toString()</tt>, unless <tt>a</tt> is <tt>null</tt>, in which case + * <tt>"null"</tt> is returned. + * + * @param a the array whose string representation to return + * @return a string representation of <tt>a</tt> + * @see <a + * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#... + * java.util.Arrays.toString(Object[])</a> + */ + public static String toString(Object[] a) { + if (a == null) return "null"; + if (a.length == 0) return "[]"; + + StringBuffer buf = new StringBuffer(); + + for (int i = 0; i < a.length; i++) { + if (i == 0) + buf.append('['); + else + buf.append(", "); + + buf.append(String.valueOf(a[i])); } + + buf.append("]"); + return buf.toString(); } + /** + * Returns a string representation of the contents of the specified array. The string + * representation consists of a list of the array's elements, enclosed in square brackets ( + * <tt>"[]"</tt>). Adjacent elements are separated by the characters <tt>", "</tt> (a comma + * followed by a space). Elements are converted to strings as by <tt>String.valueOf(long)</tt>. + * Returns <tt>"null"</tt> if <tt>a</tt> is <tt>null</tt>. + * + * @param a the array whose string representation to return + * @return a string representation of <tt>a</tt> + * @see <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#... + * java.util.Arrays.toString(long[])</a> + */ + public static String toString(long[] a) { + if (a == null) return "null"; + if (a.length == 0) return "[]"; + + StringBuffer buf = new StringBuffer(); + buf.append('['); + buf.append(a[0]); + + for (int i = 1; i < a.length; i++) { + buf.append(", "); + buf.append(a[i]); + } + + buf.append("]"); + return buf.toString(); + } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassLoaderUtil.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassLoaderUtil.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassLoaderUtil.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -27,9 +27,6 @@ import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmException; -import org.jbpm.graph.def.ProcessDefinition; -import org.jbpm.instantiation.ProcessClassLoader; -import org.jbpm.instantiation.ProcessClassLoaderFactory; /** * provides centralized classloader lookup. Added: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassUtil.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassUtil.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/ClassUtil.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,88 @@ +/* + * 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.util; + +/** + * Helper methods for dealing with classes. + * + * @author Alejandro Guizar + */ +public class ClassUtil { + + private ClassUtil() { + // hide default constructor to prevent instantiation + } + + /** + * Returns the simple name of the given class as specified in the source code. Returns an empty + * string if the underlying class is anonymous. + * <p> + * The simple name of an array is the simple name of the component type with "[]" appended. In + * particular the simple name of an array whose component type is anonymous is "[]". + * + * @return the simple name of the underlying class + * @see <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#g... + * java.lang.Class.getSimpleName()</a> + */ + public static String getSimpleName(Class clazz) { + if (clazz.isArray()) return getSimpleName(clazz.getComponentType()) + "[]"; + + String simpleName = getSimpleBinaryName(clazz); + if (simpleName == null) { // top level class + simpleName = clazz.getName(); + return simpleName.substring(simpleName.lastIndexOf(".") + 1); // strip the package name + } + + // Remove leading "\$[0-9]*" from the name + int length = simpleName.length(); + if (length < 1 || simpleName.charAt(0) != '$') throw new InternalError("Malformed class name"); + int index = 1; + while (index < length && isAsciiDigit(simpleName.charAt(index))) + index++; + // Eventually, this is the empty string iff this is an anonymous class + return simpleName.substring(index); + } + + /** + * Returns the "simple binary name" of the given class, i.e., the binary name without the leading + * enclosing class name. Returns <tt>null</tt> if the underlying class is a top level class. + */ + private static String getSimpleBinaryName(Class clazz) { + Class enclosingClass = clazz.getDeclaringClass(); + if (enclosingClass == null) // top level class + return null; + // Otherwise, strip the enclosing class' name + try { + return clazz.getName().substring(enclosingClass.getName().length()); + } + catch (IndexOutOfBoundsException ex) { + throw new InternalError("Malformed class name"); + } + } + + /** + * Character.isDigit answers <tt>true</tt> to some non-ascii digits. This one does not. + */ + private static boolean isAsciiDigit(char c) { + return '0' <= c && c <= '9'; + } +} Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/CollectionUtil.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/CollectionUtil.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/CollectionUtil.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,105 +0,0 @@ -/* - * 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.util; - -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * @author Alejandro Guizar - */ -public class CollectionUtil { - - /** Indicates whether collection elements should be actually checked. */ - private static final boolean DEBUG = true; - - private CollectionUtil() { - // hide default constructor to prevent instantiation - } - - /** - * Ensures that all elements of the given collection can be cast to a desired type. - * - * @param collection the collection to check - * @param type the desired type - * @return a collection of the desired type - * @throws ClassCastException if an element cannot be cast to the desired type - */ - @SuppressWarnings("unchecked") - public static <E> Collection<E> checkCollection(Collection<?> collection, Class<E> type) { - if (DEBUG) { - for (Object element : collection) { - type.cast(element); - } - } - return (Collection<E>) collection; - } - - /** - * Ensures that all elements of the given list can be cast to a desired type. - * - * @param list the list to check - * @param type the desired type - * @return a list of the desired type - * @throws ClassCastException if an element cannot be cast to the desired type - */ - @SuppressWarnings("unchecked") - public static <E> List<E> checkList(List<?> list, Class<E> type) { - if (DEBUG) { - for (Object element : list) { - type.cast(element); - } - } - return (List<E>) list; - } - - /** - * Ensures that all elements of the given set can be cast to a desired type. - * - * @param list the set to check - * @param type the desired type - * @return a set of the desired type - * @throws ClassCastException if an element cannot be cast to the desired type - */ - @SuppressWarnings("unchecked") - public static <E> Set<E> checkSet(Set<?> set, Class<E> type) { - if (DEBUG) { - for (Object element : set) { - type.cast(element); - } - } - return (Set<E>) set; - } - - @SuppressWarnings("unchecked") - public static <K, V> Map<K, V> checkMap(Map<?, ?> map, Class<K> keyType, Class<V> valueType) { - if (DEBUG) { - for (Map.Entry<?, ?> entry : map.entrySet()) { - keyType.cast(entry.getKey()); - valueType.cast(entry.getValue()); - } - } - return (Map<K, V>) map; - } -} Added: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/Semaphore.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/Semaphore.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/Semaphore.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,59 @@ +package org.jbpm.util; + +import java.io.Serializable; + +/** + * Trivial semaphore which borrows the interface of java.util.concurrent.Semaphore. + */ +public class Semaphore implements Serializable { + + private int permits; + + private static final long serialVersionUID = 1L; + + public Semaphore(int permits) { + this.permits = permits; + } + + public void release() { + release(1); + } + + public synchronized void release(int permits) { + this.permits += permits; + notifyAll(); + } + + public void acquire() throws InterruptedException { + acquire(1); + } + + public synchronized void acquire(int permits) throws InterruptedException { + while (this.permits < permits) { + wait(); + } + this.permits -= permits; + } + + public boolean tryAcquire(long timeout) throws InterruptedException { + return tryAcquire(1, timeout); + } + + public synchronized boolean tryAcquire(int permits, long timeout) throws InterruptedException { + long startTime = System.currentTimeMillis(); + while (this.permits < permits && System.currentTimeMillis() - startTime < timeout) { + wait(timeout); + } + if (this.permits >= permits) { + this.permits -= permits; + return true; + } + return false; + } + + public synchronized int drainPermits() { + int permits = this.permits; + this.permits = 0; + return permits; + } +} Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/StaticUtil.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/StaticUtil.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/main/java/org/jbpm/util/StaticUtil.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,96 +0,0 @@ -/* - * 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.util; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Map; - -public class StaticUtil { - - /* - public class MyClass ... { - static AType aStaticInMyClass = null; - static AnotherType anotherStaticInMyClass = null; - - static { - new StaticUtil.Initializer(MyClass.class) { - public void init() { - // initialize static members here - aStaticInMyClass = ...; - anotherStaticInMyClass = ...; - } - }; - } - ... - } - */ - - static Map initializers = Collections.synchronizedMap(new HashMap()); - - public abstract static class Initializer { - public Initializer(Class clazz) { - add(clazz, this); - init(); - } - public abstract void init(); - } - - /* - public class MyClass ... { - static AType aStaticInMyClass = null; - static AnotherType anotherStaticInMyClass = null; - - static { - new StaticUtil.Initializer(MyClass.class) { - public void init() { - // initialize static members here - aStaticInMyClass = ...; - anotherStaticInMyClass = ...; - } - }; - } - ... - } - */ - - private StaticUtil() { - // hide default constructor to prevent instantiation - } - - public static void add(Class clazz, Initializer initializer) { - initializers.put(clazz, initializer); - } - - public static void remove(Class clazz) { - initializers.remove(clazz); - } - - public static void reinitialize() { - Iterator iter = initializers.values().iterator(); - while (iter.hasNext()) { - Initializer initializer = (Initializer) iter.next(); - initializer.init(); - } - } -} Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/SerializabilityTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/SerializabilityTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/SerializabilityTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,111 +30,84 @@ public class SerializabilityTest extends AbstractJbpmTestCase { - String testRootDir = FileDefinitionFileSystemConfigTest.class.getProtectionDomain().getCodeSource().getLocation().getFile().toString(); - - static final String[] excusedClasses = { - "org.jbpm.ant", - "org.jbpm.context.exe.JbpmType", - "org.jbpm.db.hibernate.ConverterEnumType", - "org.jbpm.db.hibernate.Converters", - "org.jbpm.db.hibernate.JbpmNamingStrategy", - "org.jbpm.db.AbstractDbTestCase", - "org.jbpm.db.ContextSession", - "org.jbpm.db.FileSession", - "org.jbpm.db.GraphSession", - "org.jbpm.db.JbpmSession", - "org.jbpm.db.JbpmSchema", - "org.jbpm.db.JobSession", - "org.jbpm.db.LoggingSession", - "org.jbpm.db.SchedulerSession", - "org.jbpm.db.TaskMgmtSession", - "org.jbpm.db.compatibility.JbpmSchemaUpdate", - "org.jbpm.graph.exe.ExecutionContext", + String testRootDir = FileDefinitionFileSystemConfigTest.class.getProtectionDomain() + .getCodeSource() + .getLocation() + .getFile() + .toString(); + + static final String[] excusedClasses = { "org.jbpm.ant", "org.jbpm.context.exe.JbpmType", + "org.jbpm.db.hibernate.ConverterEnumType", "org.jbpm.db.hibernate.Converters", + "org.jbpm.db.hibernate.JbpmNamingStrategy", "org.jbpm.db.AbstractDbTestCase", + "org.jbpm.db.ContextSession", "org.jbpm.db.FileSession", "org.jbpm.db.GraphSession", + "org.jbpm.db.JbpmSession", "org.jbpm.db.JbpmSchema", "org.jbpm.db.JobSession", + "org.jbpm.db.LoggingSession", "org.jbpm.db.SchedulerSession", "org.jbpm.db.TaskMgmtSession", + "org.jbpm.db.compatibility.JbpmSchemaUpdate", "org.jbpm.graph.exe.ExecutionContext", "org.jbpm.instantiation.BeanInstantiator", "org.jbpm.instantiation.ConfigurationPropertyInstantiator", "org.jbpm.instantiation.ConstructorInstantiator", - "org.jbpm.instantiation.DefaultInstantiator", - "org.jbpm.instantiation.FieldInstantiator", - "org.jbpm.instantiation.ProcessClassLoader", - "org.jbpm.instantiation.XmlInstantiator", - "org.jbpm.JbpmConfiguration", - "org.jbpm.job.executor.JobExecutorThread", - "org.jbpm.job.executor.LockMonitorThread", - "org.jbpm.jpdl.convert.Converter", - "org.jbpm.graph.action.ActionTypes", - "org.jbpm.graph.node.Fork$ForkedToken", - "org.jbpm.graph.node.InterleaveStart$DefaultInterleaver", - "org.jbpm.graph.node.NodeTypes", - "org.jbpm.graph.node.ProcessFactory", - "org.jbpm.jpdl.par.FileArchiveParser", - "org.jbpm.jpdl.par.JpdlArchiveParser", - "org.jbpm.jpdl.par.ProcessArchive", - "org.jbpm.jpdl.par.ProcessArchiveDeployer", - "org.jbpm.jpdl.par.ProcessArchiveDeployerTask", - "org.jbpm.jpdl.xml.JpdlXmlReader", - "org.jbpm.jpdl.xml.JpdlXmlWriter", - "org.jbpm.jpdl.el", + "org.jbpm.instantiation.DefaultInstantiator", "org.jbpm.instantiation.FieldInstantiator", + "org.jbpm.instantiation.ProcessClassLoader", "org.jbpm.instantiation.XmlInstantiator", + "org.jbpm.JbpmConfiguration", "org.jbpm.job.executor.JobExecutorThread", + "org.jbpm.job.executor.LockMonitorThread", "org.jbpm.jpdl.convert.Converter", + "org.jbpm.graph.action.ActionTypes", "org.jbpm.graph.node.Fork$ForkedToken", + "org.jbpm.graph.node.InterleaveStart$DefaultInterleaver", "org.jbpm.graph.node.NodeTypes", + "org.jbpm.graph.node.ProcessFactory", "org.jbpm.jpdl.par.FileArchiveParser", + "org.jbpm.jpdl.par.JpdlArchiveParser", "org.jbpm.jpdl.par.ProcessArchive", + "org.jbpm.jpdl.par.ProcessArchiveDeployer", "org.jbpm.jpdl.par.ProcessArchiveDeployerTask", + "org.jbpm.jpdl.xml.JpdlXmlReader", "org.jbpm.jpdl.xml.JpdlXmlWriter", "org.jbpm.jpdl.el", "org.jbpm.security.authenticator.JBossAuthenticator", "org.jbpm.security.authenticator.JbpmDefaultAuthenticator", - "org.jbpm.security.authenticator.SubjectAuthenticator", - "org.jbpm.security.Authorization", + "org.jbpm.security.authenticator.SubjectAuthenticator", "org.jbpm.security.Authorization", "org.jbpm.security.authorizer.AccessControllerAuthorizer", "org.jbpm.security.authorizer.JbpmIdentityAuthorizer", "org.jbpm.security.authorizer.RolesAuthorizer", "org.jbpm.security.filter.JbpmAuthenticationFilter", - "org.jbpm.command.service.CommandServiceImpl", - "org.jbpm.sim.", - "org.jbpm.util.Clock", - "org.jbpm.util.CustomLoaderObjectInputStream", - "org.jbpm.web.JobExecutorLauncher", - "org.jbpm.web.JbpmConfigurationCloser", - "org.jbpm.JbpmContextTestHelper", - "org.jbpm.EventCallback$1" - }; + "org.jbpm.command.service.CommandServiceImpl", "org.jbpm.sim.", "org.jbpm.util.Clock", + "org.jbpm.util.CustomLoaderObjectInputStream", "org.jbpm.web.JobExecutorLauncher", + "org.jbpm.web.JbpmConfigurationCloser", "org.jbpm.JbpmContextTestHelper", + "org.jbpm.EventCallback$1" }; public void testForNonSerializableClasses() { - File jbpmRoot = new File(testRootDir+"../classes/"); + File jbpmRoot = new File(testRootDir + "../classes/"); scanForClasses(jbpmRoot, ""); } - + private void scanForClasses(File rootClassDir, String packageDir) { - File packageDirFile = new File(rootClassDir.getPath()+"/"+packageDir); + File packageDirFile = new File(rootClassDir.getPath() + "/" + packageDir); File[] files = packageDirFile.listFiles(); - for (int i=0; i<files.length; i++) { + for (int i = 0; i < files.length; i++) { if (files[i].isDirectory()) { - String newPackageDir = ( "".equals(packageDir) ? files[i].getName() : packageDir+"/"+files[i].getName() ); + String newPackageDir = ("".equals(packageDir) ? files[i].getName() : packageDir + + "/" + + files[i].getName()); // log.debug("descending into directory "+newPackageDir); scanForClasses(rootClassDir, newPackageDir); - - } else if ( (files[i].isFile()) - && (files[i].getName().endsWith(".class")) - ) { + + } + else if ((files[i].isFile()) && (files[i].getName().endsWith(".class"))) { // log.debug("found class file "+files[i].getName()); - String classFilePath = packageDir+"/"+files[i].getName(); + String classFilePath = packageDir + "/" + files[i].getName(); String className = classFilePath.replace('/', '.'); - className = className.substring(0, className.length()-6); + className = className.substring(0, className.length() - 6); assertSerializabilityOfClass(className); } } } private void assertSerializabilityOfClass(String className) { - Class<?> clazz = ClassLoaderUtil.loadClass(className); - - if ( ! ( Serializable.class.isAssignableFrom(clazz) - || Modifier.isAbstract(clazz.getModifiers()) - || isExcused(className) - || clazz.getConstructors().length == 0 - ) - ) { - fail(className+" is NOT Serializable"); + Class clazz = ClassLoaderUtil.loadClass(className); + + if (!(Serializable.class.isAssignableFrom(clazz) + || Modifier.isAbstract(clazz.getModifiers()) + || isExcused(className) || clazz.getConstructors().length == 0)) { + fail(className + " is NOT Serializable"); } } boolean isExcused(String className) { - for (String excusedClassName : excusedClasses) { - if (className.startsWith(excusedClassName)) - return true; + for (int i = 0; i < excusedClasses.length; i++) { + if (className.startsWith(excusedClasses[i])) return true; } return false; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ChangeProcessInstanceVersionCommandTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ChangeProcessInstanceVersionCommandTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ChangeProcessInstanceVersionCommandTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -17,25 +17,22 @@ * * @author bernd.ruecker(a)camunda.com */ -public class ChangeProcessInstanceVersionCommandTest extends AbstractDbTestCase -{ - +public class ChangeProcessInstanceVersionCommandTest extends AbstractDbTestCase { + private ProcessDefinition pd1; private ProcessDefinition pd2; - - @Override - protected void tearDown() throws Exception - { - if (pd1!=null && pd2!=null) { + + protected void tearDown() throws Exception { + if (pd1 != null && pd2 != null) { newTransaction(); // IMPORTANT: The ProcessDefinitions have to be deleted in one transaction, // in the right order (new definition with ProcessInstance first) or the // ProcessInstance has to be deleted first independently. - + // This is because Logs of the ProcessInstance point to both ProcessDefinitions // (the old and the new one) but only with the new ProcessDefinition the // ProcessInstance is deleted - + // exceptions look like this: could not delete: [org.jbpm.graph.def.Transition#9] // Integrity constraint violation FK_LOG_TRANSITION table: JBPM_LOG in statement [/* delete org.jbpm.graph.def.Transition */ delete from JBPM_TRANSITION where ID_=?] // or hibernate batch failed @@ -49,26 +46,26 @@ // Integrity constraint violation FK_TASKMGTINST_TMD table: JBPM_MODULEINSTANCE in statement [/* delete org.jbpm.taskmgmt.def.TaskMgmtDefinition */ delete from JBPM_MODULEDEFINITION where ID_=?] jbpmContext.getGraphSession().deleteProcessDefinition(pd2.getId()); jbpmContext.getGraphSession().deleteProcessDefinition(pd1.getId()); - } else if (pd1!=null) { + } + else if (pd1 != null) { newTransaction(); jbpmContext.getGraphSession().deleteProcessDefinition(pd1.getId()); - } else if (pd2!=null) { + } + else if (pd2 != null) { newTransaction(); - jbpmContext.getGraphSession().deleteProcessDefinition(pd2.getId()); + jbpmContext.getGraphSession().deleteProcessDefinition(pd2.getId()); } - - pd1=null; - pd2=null; + + pd1 = null; + pd2 = null; super.tearDown(); } /** - * test easy version migration (no fork or other stuff) - * but with name mapping (different state name in new process - * definition) + * test easy version migration (no fork or other stuff) but with name mapping (different state + * name in new process definition) */ - public void testNameMapping() throws Exception - { + public void testNameMapping() throws Exception { String xmlVersion1 = // "<process-definition name='TestChangeVersion'>" // + " <start-state name='start'>" // @@ -114,20 +111,20 @@ pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); // now change all process instances to most current version - try - { - new ChangeProcessInstanceVersionCommand().processName("TestChangeVersion").execute(jbpmContext); + try { + new ChangeProcessInstanceVersionCommand().processName("TestChangeVersion").execute( + jbpmContext); fail("Exception expected, saying that state2 is missing in new version"); } - catch (JbpmException ex) - { + catch (JbpmException ex) { assertEquals("node with name 'state2' not found in new process definition", ex.getMessage()); } HashMap nameMap = new HashMap(); nameMap.put("state2", "state2b"); // now supply a mapping for the missing node - new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap).processName("TestChangeVersion").execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap).processName( + "TestChangeVersion").execute(jbpmContext); newTransaction(); pi1 = graphSession.loadProcessInstance(pi1.getId()); @@ -149,15 +146,14 @@ assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); assertTrue(pi1.hasEnded()); assertEquals(pd2.getNode("end").getId(), pi2.getRootToken().getNode().getId()); - assertTrue(pi2.hasEnded()); + assertTrue(pi2.hasEnded()); } /** - * check that update of nodes work correctly if a fork was involved - * and multiple child tokens exist + * check that update of nodes work correctly if a fork was involved and multiple child tokens + * exist */ - public void testSubTokensInFork() throws Exception - { + public void testSubTokensInFork() throws Exception { String xmlVersion1 = // "<process-definition name='TestChangeVersion'>" // + " <start-state name='start'>" // @@ -213,20 +209,19 @@ pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); // now change all process instances to most current version - try - { + try { new ChangeProcessInstanceVersionCommand().processInstanceId(pi1.getId()).execute(jbpmContext); fail("Exception expected, saying that phase2 is missing in new version"); } - catch (JbpmException ex) - { + catch (JbpmException ex) { assertEquals("node with name 'path2' not found in new process definition", ex.getMessage()); } HashMap nameMap = new HashMap(); nameMap.put("path2", "path2b"); // now supply a mapping for the missing node - new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap).processInstanceId(pi1.getId()).execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap).processInstanceId( + pi1.getId()).execute(jbpmContext); newTransaction(); @@ -244,43 +239,42 @@ assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); assertTrue(pi1.hasEnded()); } - - public void testTaskInFork() throws Exception - { + + public void testTaskInFork() throws Exception { String xmlVersion1 = // - "<process-definition name='TestChangeVersion'>" // - + " <start-state name='start'>" // - + " <transition to='fork' />" // - + " </start-state>" // - + " <fork name='fork'>" // - + " <transition name='path1' to='task1' />" // - + " <transition name='path2' to='task2' />" // - + " </fork>" // - + " <task-node name='task1'>" // - + " <task name='theTask1' />" // - + " <transition to='join' />" // - + " </task-node>" // - + " <task-node name='task2'>" // - + " <task name='theTask2' />" // - + " <transition to='join' />" // - + " </task-node>" // - + " <join name='join'>" // - + " <transition to='end' />" // - + " </join>" // - + " <end-state name='end' />" // - + "</process-definition>"; + "<process-definition name='TestChangeVersion'>" // + + " <start-state name='start'>" // + + " <transition to='fork' />" // + + " </start-state>" // + + " <fork name='fork'>" // + + " <transition name='path1' to='task1' />" // + + " <transition name='path2' to='task2' />" // + + " </fork>" // + + " <task-node name='task1'>" // + + " <task name='theTask1' />" // + + " <transition to='join' />" // + + " </task-node>" // + + " <task-node name='task2'>" // + + " <task name='theTask2' />" // + + " <transition to='join' />" // + + " </task-node>" // + + " <join name='join'>" // + + " <transition to='end' />" // + + " </join>" // + + " <end-state name='end' />" // + + "</process-definition>"; - jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion1)); - pd1 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); + jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion1)); + pd1 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); - // start instance - ProcessInstance pi1 = jbpmContext.newProcessInstance("TestChangeVersion"); - pi1.signal(); - Token t1 = pi1.getRootToken().getChild("path1"); - Token t2 = pi1.getRootToken().getChild("path2"); + // start instance + ProcessInstance pi1 = jbpmContext.newProcessInstance("TestChangeVersion"); + pi1.signal(); + Token t1 = pi1.getRootToken().getChild("path1"); + Token t2 = pi1.getRootToken().getChild("path2"); - String xmlVersion2 = // - "<process-definition name='TestChangeVersion'>" // + String xmlVersion2 = // + "<process-definition name='TestChangeVersion'>" // + " <start-state name='start'>" // + " <transition to='fork' />" // + " </start-state>" // @@ -302,75 +296,72 @@ + " <end-state name='end' />" // + "</process-definition>"; - jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion2)); - pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); + jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion2)); + pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); - HashMap<String, String> nodeNameMap = new HashMap<String, String>(); - nodeNameMap.put("task1", "task1b"); - nodeNameMap.put("task2", "task2b"); - HashMap<String, String> taskNameMap = new HashMap<String, String>(); - taskNameMap.put("theTask1", "theTask1b"); - taskNameMap.put("theTask2", "theTask2b"); + HashMap nodeNameMap = new HashMap(); + nodeNameMap.put("task1", "task1b"); + nodeNameMap.put("task2", "task2b"); + HashMap taskNameMap = new HashMap(); + taskNameMap.put("theTask1", "theTask1b"); + taskNameMap.put("theTask2", "theTask2b"); - // now supply a mapping for the missing node - new ChangeProcessInstanceVersionCommand() - .nodeNameMapping(nodeNameMap) - .taskNameMapping(taskNameMap) - .processInstanceId(pi1.getId()) - .execute(jbpmContext); + // now supply a mapping for the missing node + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nodeNameMap).taskNameMapping( + taskNameMap).processInstanceId(pi1.getId()).execute(jbpmContext); - newTransaction(); + newTransaction(); - t1 = jbpmContext.loadTokenForUpdate(t1.getId()); - assertEquals(pd2.getNode("task1b").getId(), t1.getNode().getId()); - - Iterator<TaskInstance> taskInstanceIter = t1.getProcessInstance().getTaskMgmtInstance().getTaskInstances().iterator(); - TaskInstance ti1 = taskInstanceIter.next(); - if ("theTask2b".equals(ti1.getTask().getName())) { - // this was the wrong one - ti1 = taskInstanceIter.next(); - } - assertEquals("theTask1b", ti1.getTask().getName()); - assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask1b").getId(), ti1.getTask().getId()); + t1 = jbpmContext.loadTokenForUpdate(t1.getId()); + assertEquals(pd2.getNode("task1b").getId(), t1.getNode().getId()); - ti1.end(); - - /////// - newTransaction(); - - t2 = graphSession.getToken(t2.getId()); - assertEquals(pd2.getNode("task2b").getId(), t2.getNode().getId()); + Iterator taskInstanceIter = t1.getProcessInstance() + .getTaskMgmtInstance() + .getTaskInstances() + .iterator(); + TaskInstance ti1 = (TaskInstance) taskInstanceIter.next(); + if ("theTask2b".equals(ti1.getTask().getName())) { + // this was the wrong one + ti1 = (TaskInstance) taskInstanceIter.next(); + } + assertEquals("theTask1b", ti1.getTask().getName()); + assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask1b").getId(), ti1.getTask().getId()); - taskInstanceIter = t2.getProcessInstance().getTaskMgmtInstance().getTaskInstances().iterator(); - TaskInstance ti2 = taskInstanceIter.next(); - if ("theTask1b".equals(ti2.getTask().getName())) { - // this was the wrong one - ti2 = taskInstanceIter.next(); - } - assertEquals("theTask2b", ti2.getTask().getName()); - assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask2b").getId(), ti2.getTask().getId()); + ti1.end(); - ti2.end(); - - newTransaction(); - pi1 = graphSession.loadProcessInstance(pi1.getId()); + /////// + newTransaction(); - assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); - assertTrue(pi1.hasEnded()); - closeJbpmContext(); + t2 = graphSession.getToken(t2.getId()); + assertEquals(pd2.getNode("task2b").getId(), t2.getNode().getId()); + + taskInstanceIter = t2.getProcessInstance().getTaskMgmtInstance().getTaskInstances().iterator(); + TaskInstance ti2 = (TaskInstance) taskInstanceIter.next(); + if ("theTask1b".equals(ti2.getTask().getName())) { + // this was the wrong one + ti2 = (TaskInstance) taskInstanceIter.next(); + } + assertEquals("theTask2b", ti2.getTask().getName()); + assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask2b").getId(), ti2.getTask().getId()); + + ti2.end(); + + newTransaction(); + pi1 = graphSession.loadProcessInstance(pi1.getId()); + + assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); + assertTrue(pi1.hasEnded()); + closeJbpmContext(); } - public void testSubProcesses() - { + public void testSubProcesses() { } /** - * check, that TaskInstances work (TaskInstance reference to Task has - * to be adjusted as will) + * check, that TaskInstances work (TaskInstance reference to Task has to be adjusted as will) */ - public void testTaskInstances() throws Exception - { + public void testTaskInstances() throws Exception { String xmlVersion1 = // "<process-definition name='testTaskInstances'>" // + " <start-state name='start'>" // @@ -420,36 +411,31 @@ pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("testTaskInstances"); // process instance 1 can me updated, state names haven't changed in this path: - new ChangeProcessInstanceVersionCommand() - .processInstanceId(pi1.getId()) - .execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().processInstanceId(pi1.getId()).execute(jbpmContext); HashMap nameMap = new HashMap(); nameMap.put("task2", "task2b"); // now change all process instances to most current version - try - { - new ChangeProcessInstanceVersionCommand() - .nodeNameMapping(nameMap) - .taskNameMapping(nameMap) - .processName("testTaskInstances") - .execute(jbpmContext); + try { + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap) + .taskNameMapping(nameMap) + .processName("testTaskInstances") + .execute(jbpmContext); // fail because task2 is not mapped fail("Exception expected, saying that theTask2b is missing in new version"); } - catch (JbpmException ex) - { - assertEquals("Task 'theTask2' for node 'task2b' not found in new process definition", ex.getMessage()); + catch (JbpmException ex) { + assertEquals("Task 'theTask2' for node 'task2b' not found in new process definition", + ex.getMessage()); } // now supply a mapping for the missing task nameMap.put("theTask2", "theTask2b"); - new ChangeProcessInstanceVersionCommand() - .nodeNameMapping(nameMap) - .taskNameMapping(nameMap) - .processName("testTaskInstances") - .execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap) + .taskNameMapping(nameMap) + .processName("testTaskInstances") + .execute(jbpmContext); newTransaction(); @@ -459,8 +445,14 @@ assertEquals(pd2.getNode("task1").getId(), pi1.getRootToken().getNode().getId()); assertEquals(pd2.getNode("task2b").getId(), pi2.getRootToken().getNode().getId()); - TaskInstance ti1 = pi1.getTaskMgmtInstance().getTaskInstances().iterator().next(); - TaskInstance ti2 = pi2.getTaskMgmtInstance().getTaskInstances().iterator().next(); + TaskInstance ti1 = (TaskInstance) pi1.getTaskMgmtInstance() + .getTaskInstances() + .iterator() + .next(); + TaskInstance ti2 = (TaskInstance) pi2.getTaskMgmtInstance() + .getTaskInstances() + .iterator() + .next(); assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask1").getId(), ti1.getTask().getId()); assertEquals(pd2.getTaskMgmtDefinition().getTask("theTask2b").getId(), ti2.getTask().getId()); @@ -475,25 +467,22 @@ } /** - * test if changing process version works correctly - * if a timer is included in the process definition. - * - * Important: The timer itself IS NOT changed, so - * e.g. used leaving transitions must be still existent + * test if changing process version works correctly if a timer is included in the process + * definition. Important: The timer itself IS NOT changed, so e.g. used leaving transitions must + * be still existent */ - public void testTimerInState() throws Exception - { + public void testTimerInState() throws Exception { String xmlVersion1 = // "<process-definition name='TestChangeVersion'>" // - + " <start-state name='start'>" // - + " <transition to='timer1' />"// - + " </start-state>" // - + " <state name='timer1'>" // - + " <timer name='timer1' duedate='5 seconds' transition='end' />" // - + " <transition name='end' to='end' />" // - + " </state>" // - + " <end-state name='end'/>" // - + "</process-definition>"; + + " <start-state name='start'>" // + + " <transition to='timer1' />"// + + " </start-state>" // + + " <state name='timer1'>" // + + " <timer name='timer1' duedate='5 seconds' transition='end' />" // + + " <transition name='end' to='end' />" // + + " </state>" // + + " <end-state name='end'/>" // + + "</process-definition>"; jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion1)); pd1 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); @@ -510,15 +499,15 @@ String xmlVersion2 = // "<process-definition name='TestChangeVersion'>" // - + " <start-state name='start'>" // - + " <transition to='timer2' />"// - + " </start-state>" // - + " <state name='timer2'>" // - + " <timer name='timer1' duedate='5 seconds' transition='end1' />" // - + " <transition name='end' to='end' />" // - + " </state>" // - + " <end-state name='end'/>" // - + "</process-definition>"; + + " <start-state name='start'>" // + + " <transition to='timer2' />"// + + " </start-state>" // + + " <state name='timer2'>" // + + " <timer name='timer1' duedate='5 seconds' transition='end1' />" // + + " <transition name='end' to='end' />" // + + " </state>" // + + " <end-state name='end'/>" // + + "</process-definition>"; jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion2)); pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); @@ -526,16 +515,14 @@ // change version HashMap nameMap = new HashMap(); nameMap.put("timer1", "timer2"); - new ChangeProcessInstanceVersionCommand() - .nodeNameMapping(nameMap) - .processInstanceId(pi1.getId()) - .execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap).processInstanceId( + pi1.getId()).execute(jbpmContext); // load changed stuff - newTransaction(); + newTransaction(); pi1 = graphSession.loadProcessInstance(pi1.getId()); timer = (Timer) session.createQuery("from org.jbpm.job.Timer").uniqueResult(); - + // and check again assertEquals(pd2.getNode("timer2").getId(), pi1.getRootToken().getNode().getId()); assertEquals("timer1", timer.getName()); @@ -546,22 +533,21 @@ assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); assertTrue(pi1.hasEnded()); } - - public void testTimerInTask() throws Exception - { + + public void testTimerInTask() throws Exception { String xmlVersion1 = // "<process-definition name='TestChangeVersion'>" // - + " <start-state name='start'>" // - + " <transition to='timer1' />"// - + " </start-state>" // - + " <task-node name='timer1'>" // - + " <task name='myTask'>" // - + " <timer name='timer1' duedate='5 seconds' transition='end' />" // - + " </task>" // - + " <transition name='end' to='end' />" // - + " </task-node>" // - + " <end-state name='end'/>" // - + "</process-definition>"; + + " <start-state name='start'>" // + + " <transition to='timer1' />"// + + " </start-state>" // + + " <task-node name='timer1'>" // + + " <task name='myTask'>" // + + " <timer name='timer1' duedate='5 seconds' transition='end' />" // + + " </task>" // + + " <transition name='end' to='end' />" // + + " </task-node>" // + + " <end-state name='end'/>" // + + "</process-definition>"; jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion1)); pd1 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); @@ -569,30 +555,34 @@ // start instance ProcessInstance pi1 = jbpmContext.newProcessInstance("TestChangeVersion"); pi1.signal(); -// jbpmContext.getJobSession().deleteJobsForProcessInstance(processInstance); -// NOT UNIQUE?! + // jbpmContext.getJobSession().deleteJobsForProcessInstance(processInstance); + // NOT UNIQUE?! Timer timer = (Timer) session.createQuery("from org.jbpm.job.Timer").uniqueResult(); // check timer assertNotNull("Timer is null", timer); assertEquals("timer1", timer.getName()); - assertEquals(pd1.getTaskMgmtDefinition().getTask("myTask").getId(), timer.getGraphElement().getId()); - TaskInstance ti1 = pi1.getTaskMgmtInstance().getTaskInstances().iterator().next(); + assertEquals(pd1.getTaskMgmtDefinition().getTask("myTask").getId(), timer.getGraphElement() + .getId()); + TaskInstance ti1 = (TaskInstance) pi1.getTaskMgmtInstance() + .getTaskInstances() + .iterator() + .next(); assertEquals(pd1.getTaskMgmtDefinition().getTask("myTask").getId(), ti1.getTask().getId()); String xmlVersion2 = // "<process-definition name='TestChangeVersion'>" // - + " <start-state name='start'>" // - + " <transition to='timer2' />"// - + " </start-state>" // - + " <task-node name='timer2'>" // - + " <task name='myTask2'>" // - + " <timer name='timer1' duedate='5 seconds' transition='end' />" // - + " </task>" // - + " <transition name='end' to='end' />" // - + " </task-node>" // - + " <end-state name='end'/>" // - + "</process-definition>"; + + " <start-state name='start'>" // + + " <transition to='timer2' />"// + + " </start-state>" // + + " <task-node name='timer2'>" // + + " <task name='myTask2'>" // + + " <timer name='timer1' duedate='5 seconds' transition='end' />" // + + " </task>" // + + " <transition name='end' to='end' />" // + + " </task-node>" // + + " <end-state name='end'/>" // + + "</process-definition>"; jbpmContext.deployProcessDefinition(ProcessDefinition.parseXmlString(xmlVersion2)); pd2 = jbpmContext.getGraphSession().findLatestProcessDefinition("TestChangeVersion"); @@ -601,22 +591,22 @@ HashMap nameMap = new HashMap(); nameMap.put("timer1", "timer2"); nameMap.put("myTask", "myTask2"); - new ChangeProcessInstanceVersionCommand() - .nodeNameMapping(nameMap) - .taskNameMapping(nameMap) - .processInstanceId(pi1.getId()) - .execute(jbpmContext); + new ChangeProcessInstanceVersionCommand().nodeNameMapping(nameMap) + .taskNameMapping(nameMap) + .processInstanceId(pi1.getId()) + .execute(jbpmContext); // load changed stuff - newTransaction(); + newTransaction(); pi1 = graphSession.loadProcessInstance(pi1.getId()); timer = (Timer) session.createQuery("from org.jbpm.job.Timer").uniqueResult(); - + // and check again assertEquals(pd2.getNode("timer2").getId(), pi1.getRootToken().getNode().getId()); assertEquals("timer1", timer.getName()); - assertEquals(pd2.getTaskMgmtDefinition().getTask("myTask2").getId(), timer.getGraphElement().getId()); - ti1 = pi1.getTaskMgmtInstance().getTaskInstances().iterator().next(); + assertEquals(pd2.getTaskMgmtDefinition().getTask("myTask2").getId(), timer.getGraphElement() + .getId()); + ti1 = (TaskInstance) pi1.getTaskMgmtInstance().getTaskInstances().iterator().next(); assertEquals(pd2.getTaskMgmtDefinition().getTask("myTask2").getId(), ti1.getTask().getId()); // and go on @@ -624,20 +614,18 @@ assertEquals(pd2.getNode("end").getId(), pi1.getRootToken().getNode().getId()); assertTrue(pi1.hasEnded()); - } - - public void testTimerInProcessDefinition() throws Exception - { + } + + public void testTimerInProcessDefinition() throws Exception { // TODO } /** - * Asynchronous continuation is not affected by changing the version, - * because a {@link Job} only holds {@link ProcessInstance}.id, {@link Token}.id - * or {@link TaskInstance}.id. None of them are changed while version changes. + * Asynchronous continuation is not affected by changing the version, because a {@link Job} only + * holds {@link ProcessInstance}.id, {@link Token}.id or {@link TaskInstance}.id. None of them are + * changed while version changes. */ - public void notestAsync() - { + public void notestAsync() { } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -9,127 +9,118 @@ import org.jbpm.graph.exe.Token; /** - * Tests for {@link Command}s working on {@link ProcessInstance} + * Tests for {@link Command}s working on {@link ProcessInstance} * * @author bernd.ruecker(a)camunda.com */ -public class ProcessInstanceCommandTest extends AbstractDbTestCase -{ +public class ProcessInstanceCommandTest extends AbstractDbTestCase { + private ProcessDefinition processDefinition; - - @Override - protected void tearDown() throws Exception - { - if (processDefinition!=null) { + + protected void tearDown() throws Exception { + if (processDefinition != null) { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } - processDefinition=null; - + processDefinition = null; + super.tearDown(); } - - public void testEmpty() {} public void testCancelProcessInstanceCommand() throws Exception { - String xml = // - "<?xml version='1.0' encoding='UTF-8'?>" // - +"<process-definition name='TestException'>" // - +" <start-state name='start'>" // - +" <transition to='fork' />" // - +" </start-state>" // - +" <fork name='fork'>" // - +" <transition name='path1' to='path1' />" // - +" <transition name='path2' to='path2' />" // - +" </fork>" // - +" <state name='path1'>" // - +" <transition to='join' />" // - +" </state>" // - +" <state name='path2'>" // - +" <transition to='join' />" // - +" </state>" // - +" <join name='join'>" // - +" <transition to='end' />" // - +" </join>" // - +" <end-state name='end' />" // - +"</process-definition>"; - - processDefinition = ProcessDefinition.parseXmlString(xml); + String xml = "<process-definition name='TestException'>" + + " <start-state name='start'>" + + " <transition to='fork' />" + + " </start-state>" + + " <fork name='fork'>" + + " <transition name='path1' to='path1' />" + + " <transition name='path2' to='path2' />" + + " </fork>" + + " <state name='path1'>" + + " <transition to='join' />" + + " </state>" + + " <state name='path2'>" + + " <transition to='join' />" + + " </state>" + + " <join name='join'>" + + " <transition to='end' />" + + " </join>" + + " <end-state name='end' />" + + "</process-definition>"; + + processDefinition = ProcessDefinition.parseXmlString(xml); jbpmContext.deployProcessDefinition(processDefinition); ProcessInstance processInstance = processDefinition.createProcessInstance(); processInstance.getRootToken().signal(); processInstance = saveAndReload(processInstance); - + assertFalse(processInstance.getRootToken().hasEnded()); assertEquals("fork", processInstance.getRootToken().getNode().getName()); - for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) - { - Token childToken = (Token)iterator.next(); + for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) { + Token childToken = (Token) iterator.next(); assertFalse(childToken.hasEnded()); } // execute CancelProcessInstanceCommand new CancelProcessInstanceCommand(processInstance.getId()).execute(jbpmContext); - + // and verify it is canceled assertTrue(processInstance.getRootToken().hasEnded()); assertEquals("fork", processInstance.getRootToken().getNode().getName()); - for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) - { - Token childToken = (Token)iterator.next(); + for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) { + Token childToken = (Token) iterator.next(); assertTrue(childToken.hasEnded()); } } - + public void testSuspendResumeProcessInstanceCommand() throws Exception { String xml = // - "<?xml version='1.0' encoding='UTF-8'?>" // - +"<process-definition name='TestException'>" // - +" <start-state name='start'>" // - +" <transition to='fork' />" // - +" </start-state>" // - +" <fork name='fork'>" // - +" <transition name='path1' to='path1' />" // - +" <transition name='path2' to='path2' />" // - +" </fork>" // - +" <state name='path1'>" // - +" <transition to='join' />" // - +" </state>" // - +" <state name='path2'>" // - +" <transition to='join' />" // - +" </state>" // - +" <join name='join'>" // - +" <transition to='end' />" // - +" </join>" // - +" <end-state name='end' />" // - +"</process-definition>"; - - processDefinition = ProcessDefinition.parseXmlString(xml); + "<?xml version='1.0' encoding='UTF-8'?>" // + + "<process-definition name='TestException'>" // + + " <start-state name='start'>" // + + " <transition to='fork' />" // + + " </start-state>" // + + " <fork name='fork'>" // + + " <transition name='path1' to='path1' />" // + + " <transition name='path2' to='path2' />" // + + " </fork>" // + + " <state name='path1'>" // + + " <transition to='join' />" // + + " </state>" // + + " <state name='path2'>" // + + " <transition to='join' />" // + + " </state>" // + + " <join name='join'>" // + + " <transition to='end' />" // + + " </join>" // + + " <end-state name='end' />" // + + "</process-definition>"; + + processDefinition = ProcessDefinition.parseXmlString(xml); jbpmContext.deployProcessDefinition(processDefinition); ProcessInstance processInstance = processDefinition.createProcessInstance(); processInstance.getRootToken().signal(); processInstance = saveAndReload(processInstance); - + assertFalse(processInstance.isSuspended()); assertFalse(processInstance.getRootToken().isSuspended()); assertEquals("fork", processInstance.getRootToken().getNode().getName()); - for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) - { - Token childToken = (Token)iterator.next(); + for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) { + Token childToken = (Token) iterator.next(); assertFalse(childToken.isSuspended()); } // execute SuspendProcessInstanceCommand - new SuspendProcessInstanceCommand().processInstanceId(processInstance.getId()).execute(jbpmContext); - + new SuspendProcessInstanceCommand().processInstanceId(processInstance.getId()).execute( + jbpmContext); + // and verify assertTrue(processInstance.isSuspended()); assertTrue(processInstance.getRootToken().isSuspended()); assertEquals("fork", processInstance.getRootToken().getNode().getName()); - for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) - { - Token childToken = (Token)iterator.next(); + for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) { + Token childToken = (Token) iterator.next(); assertTrue(childToken.isSuspended()); - + try { childToken.signal(); fail("signal should not be accepted on suspended token"); @@ -137,32 +128,32 @@ catch (Exception ex) { assertEquals(JbpmException.class, ex.getClass()); // can't signal token 'path1' (5): it is suspended - assertTrue("exception should be, that token is suspended", ex.getMessage().indexOf("it is suspended")>0); + assertTrue("exception should be, that token is suspended", ex.getMessage().indexOf( + "it is suspended") > 0); } } - + // execute ResumeProcessInstanceCommand - new ResumeProcessInstanceCommand().processInstanceId(processInstance.getId()).execute(jbpmContext); + new ResumeProcessInstanceCommand().processInstanceId(processInstance.getId()).execute( + jbpmContext); // and verify assertFalse(processInstance.isSuspended()); assertFalse(processInstance.getRootToken().isSuspended()); - for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) - { - Token childToken = (Token)iterator.next(); + for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) { + Token childToken = (Token) iterator.next(); assertFalse(childToken.isSuspended()); childToken.signal(); } - + assertEquals("end", processInstance.getRootToken().getNode().getName()); assertTrue(processInstance.hasEnded()); // check db state - processInstance = saveAndReload(processInstance); + processInstance = saveAndReload(processInstance); assertEquals("end", processInstance.getRootToken().getNode().getName()); assertTrue(processInstance.hasEnded()); - } - + } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/TokenVariableMapDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/TokenVariableMapDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/TokenVariableMapDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -31,8 +31,7 @@ import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.exe.Token; -public class TokenVariableMapDbTest extends AbstractDbTestCase -{ +public class TokenVariableMapDbTest extends AbstractDbTestCase { ProcessDefinition processDefinition; ProcessInstance processInstance; @@ -41,8 +40,7 @@ Map tokenVariableMaps; TokenVariableMap tokenVariableMap; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition(); @@ -59,42 +57,37 @@ contextInstance.tokenVariableMaps = tokenVariableMaps; } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testTokenVariableMapContextInstance() - { + public void testTokenVariableMapContextInstance() { processInstance = saveAndReload(processInstance); token = processInstance.getRootToken(); contextInstance = processInstance.getContextInstance(); tokenVariableMaps = contextInstance.tokenVariableMaps; - tokenVariableMap = (TokenVariableMap)tokenVariableMaps.get(token); + tokenVariableMap = (TokenVariableMap) tokenVariableMaps.get(token); assertSame(contextInstance, tokenVariableMap.getContextInstance()); } - public void testTokenVariableMapToken() - { + public void testTokenVariableMapToken() { processInstance = saveAndReload(processInstance); token = processInstance.getRootToken(); contextInstance = processInstance.getContextInstance(); tokenVariableMaps = contextInstance.tokenVariableMaps; - tokenVariableMap = (TokenVariableMap)tokenVariableMaps.get(token); + tokenVariableMap = (TokenVariableMap) tokenVariableMaps.get(token); assertSame(token, tokenVariableMap.getToken()); } - public void testTokenVariableMapVariableInstances() - { - StringInstance stringVariable = (StringInstance)VariableInstance.create(token, "one", "hello"); + public void testTokenVariableMapVariableInstances() { + StringInstance stringVariable = (StringInstance) VariableInstance.create(token, "one", "hello"); tokenVariableMap.addVariableInstance(stringVariable); - stringVariable = (StringInstance)VariableInstance.create(token, "two", "world"); + stringVariable = (StringInstance) VariableInstance.create(token, "two", "world"); tokenVariableMap.addVariableInstance(stringVariable); processInstance = saveAndReload(processInstance); @@ -102,12 +95,14 @@ token = processInstance.getRootToken(); contextInstance = processInstance.getContextInstance(); tokenVariableMaps = contextInstance.tokenVariableMaps; - tokenVariableMap = (TokenVariableMap)tokenVariableMaps.get(processInstance.getRootToken()); + tokenVariableMap = (TokenVariableMap) tokenVariableMaps.get(processInstance.getRootToken()); // System.out.println(tokenVariableMap.getVariable("one")); // System.out.println(tokenVariableMap.getVariable("two")); - assertEquals("hello", ((StringInstance)tokenVariableMap.variableInstances.get("one")).getValue()); - assertEquals("world", ((StringInstance)tokenVariableMap.variableInstances.get("two")).getValue()); + assertEquals("hello", + ((StringInstance) tokenVariableMap.variableInstances.get("one")).getValue()); + assertEquals("world", + ((StringInstance) tokenVariableMap.variableInstances.get("two")).getValue()); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableInstanceDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableInstanceDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableInstanceDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,6 +29,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmException; import org.jbpm.context.def.ContextDefinition; import org.jbpm.db.AbstractDbTestCase; @@ -36,15 +37,13 @@ import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.util.DateDbTestUtil; -public class VariableInstanceDbTest extends AbstractDbTestCase -{ +public class VariableInstanceDbTest extends AbstractDbTestCase { ProcessDefinition processDefinition; ProcessInstance processInstance; ContextInstance contextInstance; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition(); @@ -55,25 +54,22 @@ contextInstance = processInstance.getContextInstance(); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testVariableInstanceString() - { + public void testVariableInstanceString() { contextInstance.setVariable("comment", "it's not the size that matters, it's how you use it."); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); - assertEquals("it's not the size that matters, it's how you use it.", contextInstance.getVariable("comment")); + assertEquals("it's not the size that matters, it's how you use it.", + contextInstance.getVariable("comment")); } - public void testVariableInstanceLong() - { + public void testVariableInstanceLong() { contextInstance.setVariable("new salary", new Long(500000)); processInstance = saveAndReload(processInstance); @@ -82,8 +78,7 @@ assertEquals(new Long(500000), contextInstance.getVariable("new salary")); } - public void testVariableInstanceByteArray() - { + public void testVariableInstanceByteArray() { String text = "oh, what a wonderfull world"; for (int i = 0; i < 10; i++) text += text; @@ -94,125 +89,122 @@ processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); - bytes = (byte[])contextInstance.getVariable("a lot of bytes"); + bytes = (byte[]) contextInstance.getVariable("a lot of bytes"); assertEquals(text, new String(bytes)); } - public void testString() - { + public void testString() { contextInstance.setVariable("a", new String("3")); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals("3", contextInstance.getVariable("a")); } - public void testBoolean() - { + public void testBoolean() { contextInstance.setVariable("a", Boolean.TRUE); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(Boolean.TRUE, contextInstance.getVariable("a")); } - public void testCharacter() - { + public void testCharacter() { contextInstance.setVariable("a", new Character('c')); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Character('c'), contextInstance.getVariable("a")); } - public void testFloat() - { + public void testFloat() { contextInstance.setVariable("a", new Float(3.3)); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Float(3.3), contextInstance.getVariable("a")); } - public void testDouble() - { + public void testDouble() { contextInstance.setVariable("a", new Double(3.3)); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Double(3.3), contextInstance.getVariable("a")); } - public static class MySerializableClass implements Serializable - { + public static class MySerializableClass implements Serializable { + private static final long serialVersionUID = 1L; int member; - MySerializableClass(int member) - { + MySerializableClass(int member) { this.member = member; } - public boolean equals(Object o) - { - if (!(o instanceof MySerializableClass)) - return false; - return (member == ((MySerializableClass)o).member); + public boolean equals(Object o) { + if (!(o instanceof MySerializableClass)) return false; + return (member == ((MySerializableClass) o).member); } } - public void testCustomTypeSerializable() - { + public void testCustomTypeSerializable() { contextInstance.setVariable("a", new MySerializableClass(4)); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new MySerializableClass(4), contextInstance.getVariable("a")); } - public void testLong() - { + public void testLong() { contextInstance.setVariable("a", new Long(3)); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Long(3), contextInstance.getVariable("a")); } - public void testByte() - { + public void testByte() { contextInstance.setVariable("a", new Byte("3")); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Byte("3"), contextInstance.getVariable("a")); } - public void testShort() - { + public void testShort() { contextInstance.setVariable("a", new Short("3")); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Short("3"), contextInstance.getVariable("a")); } - public void testInteger() - { + public void testInteger() { contextInstance.setVariable("a", new Integer(3)); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); assertEquals(new Integer(3), contextInstance.getVariable("a")); } - public void testDate() - { + public void testDate() { final Date now = Calendar.getInstance().getTime(); contextInstance.setVariable("a", now); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); - final Date result = (Date)contextInstance.getVariable("a"); + final Date result = (Date) contextInstance.getVariable("a"); // assertEquals(expected, result); - log.info("Now: " + now + ", " + now.getTime() + ", " + DateDbTestUtil.getInstance().convertDateToSeconds(now)); - log.info("Now: " + result + ", " + result.getTime() + ", " + DateDbTestUtil.getInstance().convertDateToSeconds(result)); - assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now), DateDbTestUtil.getInstance().convertDateToSeconds(result)); - assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now), DateDbTestUtil.getInstance().convertDateToSeconds(result)); + log.info("Now: " + + now + + ", " + + now.getTime() + + ", " + + DateDbTestUtil.getInstance().convertDateToSeconds(now)); + log.info("Now: " + + result + + ", " + + result.getTime() + + ", " + + DateDbTestUtil.getInstance().convertDateToSeconds(result)); + assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now), + DateDbTestUtil.getInstance().convertDateToSeconds(result)); + assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now), + DateDbTestUtil.getInstance().convertDateToSeconds(result)); } - public void testNullUpdate() - { + public void testNullUpdate() { contextInstance.setVariable("a", "blablabla"); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); @@ -222,8 +214,7 @@ assertNull(contextInstance.getVariable("a")); } - public void testChangeTypeWithDeleteIsAllowed() - { + public void testChangeTypeWithDeleteIsAllowed() { contextInstance.setVariable("a", new String("3")); processInstance = saveAndReload(processInstance); contextInstance = processInstance.getContextInstance(); @@ -233,8 +224,7 @@ contextInstance.setVariable("a", new Integer(3)); } - public void testSerializableCollection() - { + public void testSerializableCollection() { List l = new ArrayList(); l.add("one"); l.add("two"); @@ -245,16 +235,13 @@ assertEquals(l, contextInstance.getVariable("l")); } - public void testNonStorableType() - { + public void testNonStorableType() { contextInstance.setVariable("t", new Thread()); - try - { + try { jbpmContext.save(processInstance); fail("expected exception"); } - catch (JbpmException e) - { + catch (JbpmException e) { // OK // let's make sure the auto flushing of hibernate doesn't explode contextInstance.deleteVariable("t"); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableQueryDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableQueryDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/exe/VariableQueryDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,10 +1,10 @@ package org.jbpm.context.exe; -import java.util.Collections; import java.util.HashSet; import java.util.Set; import org.hibernate.Query; + import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; @@ -33,38 +33,32 @@ newTransaction(); + Set expectedPids = new HashSet(); + expectedPids.add(new Long(one.getId())); + expectedPids.add(new Long(two.getId())); + Query query = session.createQuery("select pi.id " + "from org.jbpm.context.exe.variableinstance.StringInstance si " + "join si.processInstance pi " + "where si.name = 'category'" + " and si.value like 'overpaid'"); + Set retrievedPids = new HashSet(query.list()); - Set<Long> expectedPids = new HashSet<Long>(); - expectedPids.add(one.getId()); - expectedPids.add(two.getId()); - - Set<Long> retrievedPids = new HashSet<Long>(); - for (Object result : query.list()) { - retrievedPids.add((Long) result); - } - assertEquals(expectedPids, retrievedPids); newTransaction(); + expectedPids.clear(); + expectedPids.add(new Long(three.getId())); + query = session.createQuery("select pi.id " + "from org.jbpm.context.exe.variableinstance.StringInstance si " + "join si.processInstance pi " + "where si.name = 'category'" + " and si.value like 'underpaid'"); + retrievedPids.clear(); + retrievedPids.addAll(query.list()); - expectedPids = Collections.singleton(three.getId()); - - retrievedPids = new HashSet<Long>(); - for (Object result : query.list()) { - retrievedPids.add((Long) result); - } - assertEquals(expectedPids, retrievedPids); } finally { Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -35,14 +35,13 @@ import org.jbpm.logging.exe.LoggingInstance; import org.jbpm.util.DateDbTestUtil; -public class VariableUpdateDbTest extends AbstractDbTestCase -{ +public class VariableUpdateDbTest extends AbstractDbTestCase { + private ProcessDefinition processDefinition; private ProcessInstance processInstance; private ContextInstance contextInstance; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition(); processDefinition.addDefinition(new ContextDefinition()); @@ -52,39 +51,37 @@ contextInstance = processInstance.getContextInstance(); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testVariableCreateLogs() - { + public void testVariableCreateLogs() { contextInstance.setVariable("a", new Integer(3)); jbpmContext.save(processInstance); newTransaction(); List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId()); - VariableCreateLog createLog = (VariableCreateLog)LoggingInstance.getLogs(logs, VariableCreateLog.class).get(0); + VariableCreateLog createLog = (VariableCreateLog) LoggingInstance.getLogs(logs, + VariableCreateLog.class).get(0); assertEquals("a", createLog.getVariableInstance().getName()); } - public void testByteArrayUpdateLog() - { + public void testByteArrayUpdateLog() { contextInstance.setVariable("a", "first value".getBytes()); jbpmContext.save(processInstance); contextInstance.setVariable("a", "second value".getBytes()); VariableUpdateLog variableLog = saveAndReloadUpdateLog(processInstance); - assertTrue(Arrays.equals("first value".getBytes(), ((ByteArray)variableLog.getOldValue()).getBytes())); - assertTrue(Arrays.equals("second value".getBytes(), ((ByteArray)variableLog.getNewValue()).getBytes())); + assertTrue(Arrays.equals("first value".getBytes(), + ((ByteArray) variableLog.getOldValue()).getBytes())); + assertTrue(Arrays.equals("second value".getBytes(), + ((ByteArray) variableLog.getNewValue()).getBytes())); } - public void testDateUpdateLog() - { + public void testDateUpdateLog() { final Date now = Calendar.getInstance().getTime(); final Date future = new Date(now.getTime() + 5); contextInstance.setVariable("a", now); @@ -94,12 +91,13 @@ VariableUpdateLog variableLog = saveAndReloadUpdateLog(processInstance); DateDbTestUtil dbUtilInst = DateDbTestUtil.getInstance(); - assertEquals(dbUtilInst.convertDateToSeconds(now), dbUtilInst.convertDateToSeconds((Date)variableLog.getOldValue())); - assertEquals(dbUtilInst.convertDateToSeconds(future), dbUtilInst.convertDateToSeconds((Date)variableLog.getNewValue())); + assertEquals(dbUtilInst.convertDateToSeconds(now), + dbUtilInst.convertDateToSeconds((Date) variableLog.getOldValue())); + assertEquals(dbUtilInst.convertDateToSeconds(future), + dbUtilInst.convertDateToSeconds((Date) variableLog.getNewValue())); } - public void testDoubleUpdateLog() - { + public void testDoubleUpdateLog() { contextInstance.setVariable("a", new Double(3.3)); jbpmContext.save(processInstance); contextInstance.setVariable("a", new Double(4.4)); @@ -110,8 +108,7 @@ assertEquals(new Double(4.4), variableLog.getNewValue()); } - public void testLongUpdateLog() - { + public void testLongUpdateLog() { contextInstance.setVariable("a", new Integer(3)); jbpmContext.save(processInstance); contextInstance.setVariable("a", new Integer(5)); @@ -122,8 +119,7 @@ assertEquals(new Long(5), variableLog.getNewValue()); } - public void testStringUpdateLog() - { + public void testStringUpdateLog() { contextInstance.setVariable("a", "pope"); jbpmContext.save(processInstance); contextInstance.setVariable("a", "me"); @@ -134,8 +130,7 @@ assertEquals("me", variableLog.getNewValue()); } - public void testVariableDeleteLog() - { + public void testVariableDeleteLog() { contextInstance.setVariable("a", new Integer(3)); jbpmContext.save(processInstance); contextInstance.deleteVariable("a"); @@ -143,16 +138,16 @@ jbpmContext.save(processInstance); newTransaction(); List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId()); - VariableDeleteLog deleteLog = (VariableDeleteLog)LoggingInstance.getLogs(logs, VariableDeleteLog.class).get(0); + VariableDeleteLog deleteLog = (VariableDeleteLog) LoggingInstance.getLogs(logs, + VariableDeleteLog.class).get(0); assertEquals("a", deleteLog.getVariableInstance().getName()); } - private VariableUpdateLog saveAndReloadUpdateLog(ProcessInstance processInstance) - { + private VariableUpdateLog saveAndReloadUpdateLog(ProcessInstance processInstance) { jbpmContext.save(processInstance); newTransaction(); List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId()); - return (VariableUpdateLog)LoggingInstance.getLogs(logs, VariableUpdateLog.class).get(1); + return (VariableUpdateLog) LoggingInstance.getLogs(logs, VariableUpdateLog.class).get(1); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/JbpmSchemaDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/JbpmSchemaDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/JbpmSchemaDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,10 +21,12 @@ */ package org.jbpm.db; +import java.util.Iterator; import java.util.Map; import java.util.Set; import org.hibernate.cfg.Configuration; + import org.jbpm.AbstractJbpmTestCase; /** @@ -37,7 +39,6 @@ JbpmSchema jbpmSchema; - @Override protected void setUp() throws Exception { super.setUp(); jbpmSchema = new JbpmSchema(new Configuration().configure()); @@ -45,26 +46,28 @@ public void testCreateSchema() { jbpmSchema.createSchema(); - Set<String> existingTables = jbpmSchema.getExistingTables(); + Set existingTables = jbpmSchema.getExistingTables(); assert existingTables.containsAll(jbpmSchema.getJbpmTables()) : existingTables; } public void testDropSchema() { jbpmSchema.dropSchema(); - Set<String> existingTables = jbpmSchema.getExistingTables(); - for (String jbpmTable : jbpmSchema.getJbpmTables()) { + Set existingTables = jbpmSchema.getExistingTables(); + for (Iterator i = jbpmSchema.getJbpmTables().iterator(); i.hasNext();) { + String jbpmTable = (String) i.next(); assert !existingTables.contains(jbpmTable) : existingTables; } } public void testCleanSchema() { jbpmSchema.cleanSchema(); - Map<String, Long> rowsPerTable = jbpmSchema.getRowsPerTable(); - Set<String> existingTables = jbpmSchema.getExistingTables(); + Map rowsPerTable = jbpmSchema.getRowsPerTable(); + Set existingTables = jbpmSchema.getExistingTables(); assert existingTables.containsAll(rowsPerTable.keySet()) : existingTables; - for (long rowCount : rowsPerTable.values()) { - assertEquals(0, rowCount); + for (Iterator i = rowsPerTable.values().iterator(); i.hasNext();) { + Long rowCount = (Long) i.next(); + assertEquals(0, rowCount.longValue()); } } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/TaskMgmtSessionDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/TaskMgmtSessionDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/db/TaskMgmtSessionDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -46,7 +46,7 @@ protected void setUp() throws Exception { super.setUp(); - + processDefinition = new ProcessDefinition(); taskMgmtDefinition = new TaskMgmtDefinition(); processDefinition.addDefinition(taskMgmtDefinition); @@ -54,12 +54,12 @@ taskMgmtDefinition.addTask(laundry); dishes = new Task("dishes"); taskMgmtDefinition.addTask(dishes); - + graphSession.saveProcessDefinition(processDefinition); - + processInstance = new ProcessInstance(processDefinition); processInstance = saveAndReload(processInstance); - + processDefinition = processInstance.getProcessDefinition(); taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); laundry = taskMgmtDefinition.getTask("laundry"); @@ -67,9 +67,7 @@ taskMgmtInstance = processInstance.getTaskMgmtInstance(); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } @@ -78,13 +76,13 @@ taskMgmtInstance.addTaskInstance(new TaskInstance("laundry", "me")); taskMgmtInstance.addTaskInstance(new TaskInstance("dishes", "me")); taskMgmtInstance.addTaskInstance(new TaskInstance("vacation", "the other guy")); - + processInstance = saveAndReload(processInstance); - + List taskInstances = taskMgmtSession.findTaskInstances("me"); assertEquals(2, taskInstances.size()); - TaskInstance taskInstanceOne = (TaskInstance)taskInstances.get(0); - TaskInstance taskInstanceTwo = (TaskInstance)taskInstances.get(1); + TaskInstance taskInstanceOne = (TaskInstance) taskInstances.get(0); + TaskInstance taskInstanceTwo = (TaskInstance) taskInstances.get(1); assertEquals("me", taskInstanceOne.getActorId()); assertEquals("me", taskInstanceTwo.getActorId()); assertNotSame(taskInstanceOne, taskInstanceTwo); @@ -97,53 +95,50 @@ taskMgmtInstance.addTaskInstance(new TaskInstance("vacation", "the other guy")); taskMgmtInstance.addTaskInstance(new TaskInstance("try", "a nobody")); taskMgmtInstance.addTaskInstance(new TaskInstance("pretend", "a nobody")); - + processInstance = saveAndReload(processInstance); - - List taskInstances = taskMgmtSession.findTaskInstances(new String[]{"me", "the other guy"}); + + List taskInstances = taskMgmtSession.findTaskInstances(new String[] { "me", "the other guy" }); assertEquals(4, taskInstances.size()); } public void testLoadTaskInstance() { TaskInstance taskInstance = new TaskInstance("laundry", "me"); taskMgmtInstance.addTaskInstance(taskInstance); - + processInstance = saveAndReload(processInstance); - + taskInstance = taskMgmtSession.loadTaskInstance(taskInstance.getId()); assertNotNull(taskInstance); } public void testTaskMgmtFinderMethods() { - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString( - "<process-definition name='searchable'>" + - " <start-state>" + - " <transition to='f'/>" + - " </start-state>" + - " <fork name='f'>" + - " <transition name='washing' to='collectLaundry'/>" + - " <transition name='cleaning' to='cleanToilets'/>" + - " </fork>" + - " <task-node name='collectLaundry'>" + - " <task name='getLaundryFromBasket' />" + - " <task name='askHusbandWhereHeDumpedHisClothes' />" + - " <task name='lookUnderChildrensBeds' />" + - " </task-node>" + - " <task-node name='cleanToilets'>" + - " <task name='cleanToilets'/>" + - " </task-node>" + - "</process-definition>" - ); + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='searchable'>" + + " <start-state>" + + " <transition to='f'/>" + + " </start-state>" + + " <fork name='f'>" + + " <transition name='washing' to='collectLaundry'/>" + + " <transition name='cleaning' to='cleanToilets'/>" + + " </fork>" + + " <task-node name='collectLaundry'>" + + " <task name='getLaundryFromBasket' />" + + " <task name='askHusbandWhereHeDumpedHisClothes' />" + + " <task name='lookUnderChildrensBeds' />" + + " </task-node>" + + " <task-node name='cleanToilets'>" + + " <task name='cleanToilets'/>" + + " </task-node>" + + "</process-definition>"); jbpmContext.deployProcessDefinition(processDefinition); - try - { + try { newTransaction(); - + ProcessInstance processInstance = jbpmContext.newProcessInstance("searchable"); processInstance.signal(); - + processInstance = saveAndReload(processInstance); - + List taskInstances = taskMgmtSession.findTaskInstancesByProcessInstance(processInstance); Set collectedTaskInstanceNames = new HashSet(); Iterator iter = taskInstances.iterator(); @@ -151,15 +146,15 @@ TaskInstance taskInstance = (TaskInstance) iter.next(); collectedTaskInstanceNames.add(taskInstance.getName()); } - + Set expectedTaskInstanceNames = new HashSet(); expectedTaskInstanceNames.add("getLaundryFromBasket"); expectedTaskInstanceNames.add("askHusbandWhereHeDumpedHisClothes"); expectedTaskInstanceNames.add("lookUnderChildrensBeds"); expectedTaskInstanceNames.add("cleanToilets"); - + assertEquals(expectedTaskInstanceNames, collectedTaskInstanceNames); - + List nodes = graphSession.findActiveNodesByProcessInstance(processInstance); Set collectedNodeNames = new HashSet(); iter = nodes.iterator(); @@ -167,17 +162,16 @@ Node node = (Node) iter.next(); collectedNodeNames.add(node.getName()); } - + Set expectedNodeNames = new HashSet(); expectedNodeNames.add("collectLaundry"); expectedNodeNames.add("cleanToilets"); assertEquals(expectedNodeNames, collectedNodeNames); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } - + } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessCancellationTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessCancellationTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessCancellationTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,13 +1,14 @@ package org.jbpm.graph.exe; +import java.util.Iterator; + import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.taskmgmt.exe.TaskInstance; -public class SubProcessCancellationTest extends AbstractDbTestCase -{ - public void testWithSubProcess() - { +public class SubProcessCancellationTest extends AbstractDbTestCase { + + public void testWithSubProcess() { ProcessDefinition subProcess = ProcessDefinition.parseXmlString("<process-definition name='sub'>" + " <start-state>" + " <transition to='wait' />" @@ -35,8 +36,7 @@ jbpmContext.deployProcessDefinition(superProcess); newTransaction(); - try - { + try { ProcessInstance pi = jbpmContext.newProcessInstanceForUpdate("super"); pi.signal(); @@ -52,14 +52,13 @@ subPi = pi.getRootToken().getSubProcessInstance(); assertTrue(subPi.hasEnded()); - for (TaskInstance taskInstance : subPi.getTaskMgmtInstance().getTaskInstances()) - { + for (Iterator i = subPi.getTaskMgmtInstance().getTaskInstances().iterator(); i.hasNext();) { + TaskInstance taskInstance = (TaskInstance) i.next(); assertFalse(taskInstance.isSignalling()); assertFalse(taskInstance.hasEnded()); } } - finally - { + finally { graphSession.deleteProcessDefinition(superProcess.getId()); graphSession.deleteProcessDefinition(subProcess.getId()); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessPlusConcurrencyDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessPlusConcurrencyDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/exe/SubProcessPlusConcurrencyDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -28,58 +28,54 @@ import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.node.ProcessState; -public class SubProcessPlusConcurrencyDbTest extends AbstractDbTestCase -{ +public class SubProcessPlusConcurrencyDbTest extends AbstractDbTestCase { void deployProcessDefinitions() { - ProcessDefinition subProcess = ProcessDefinition.parseXmlString( - "<process-definition name='sub'>" + - " <start-state>" + - " <transition to='wait' />" + - " </start-state>" + - " <state name='wait'>" + - " <transition to='end' />" + - " </state>" + - " <end-state name='end' />" + - "</process-definition>" - ); + ProcessDefinition subProcess = ProcessDefinition.parseXmlString("<process-definition name='sub'>" + + " <start-state>" + + " <transition to='wait' />" + + " </start-state>" + + " <state name='wait'>" + + " <transition to='end' />" + + " </state>" + + " <end-state name='end' />" + + "</process-definition>"); jbpmContext.deployProcessDefinition(subProcess); - - ProcessDefinition superProcess = ProcessDefinition.parseXmlString( - "<process-definition name='super'>" + - " <start-state>" + - " <transition name='without subprocess' to='fork' />" + - " <transition name='with subprocess' to='subprocess' />" + - " </start-state>" + - " <process-state name='subprocess'>" + - " <sub-process name='sub' />" + - " <transition to='fork'/>" + - " </process-state>" + - " <fork name='fork'>" + - " <transition name='a' to='join' />" + - " <transition name='b' to='join' />" + - " </fork>" + - " <join name='join' lock='UPGRADE'>" + - " <transition to='s' />" + - " </join>" + - " <state name='s'>" + - " <event type='node-enter'>" + - " <action class='org.jbpm.graph.exe.SubProcessPlusConcurrencyDbTest$EnterNodeS' />" + - " </event>" + - " </state>" + - "</process-definition>" - ); + + ProcessDefinition superProcess = ProcessDefinition.parseXmlString("<process-definition name='super'>" + + " <start-state>" + + " <transition name='without subprocess' to='fork' />" + + " <transition name='with subprocess' to='subprocess' />" + + " </start-state>" + + " <process-state name='subprocess'>" + + " <sub-process name='sub' />" + + " <transition to='fork'/>" + + " </process-state>" + + " <fork name='fork'>" + + " <transition name='a' to='join' />" + + " <transition name='b' to='join' />" + + " </fork>" + + " <join name='join' lock='UPGRADE'>" + + " <transition to='s' />" + + " </join>" + + " <state name='s'>" + + " <event type='node-enter'>" + + " <action class='org.jbpm.graph.exe.SubProcessPlusConcurrencyDbTest$EnterNodeS' />" + + " </event>" + + " </state>" + + "</process-definition>"); jbpmContext.deployProcessDefinition(superProcess); - + newTransaction(); } public void deleteProcessDefinitions() { ProcessDefinition processDefinition = graphSession.findLatestProcessDefinition("super"); Node node = processDefinition.getNode("subprocess"); - ProcessState processState = (ProcessState) session.load(ProcessState.class, node.getId()); + ProcessState processState = (ProcessState) session.load(ProcessState.class, new Long( + node.getId())); processState.setSubProcessDefinition(null); - + newTransaction(); processDefinition = graphSession.findLatestProcessDefinition("sub"); @@ -94,18 +90,21 @@ } public static class EnterNodeS implements ActionHandler { + private static final long serialVersionUID = 1L; + public void execute(ExecutionContext executionContext) throws Exception { ContextInstance contextInstance = executionContext.getContextInstance(); Integer invocationCount = (Integer) contextInstance.getVariable("invocationCount"); - if (invocationCount==null) { + if (invocationCount == null) { contextInstance.setVariable("invocationCount", new Integer(1)); - } else { - contextInstance.setVariable("invocationCount", new Integer(invocationCount.intValue()+1)); } + else { + contextInstance.setVariable("invocationCount", new Integer(invocationCount.intValue() + 1)); + } } } - + public void testWithoutSubProcess() { deployProcessDefinitions(); @@ -116,7 +115,8 @@ assertEquals(new Integer(1), pi.getContextInstance().getVariable("invocationCount")); newTransaction(); - } finally { + } + finally { deleteProcessDefinitions(); } } @@ -142,7 +142,8 @@ newTransaction(); - } finally { + } + finally { deleteProcessDefinitions(); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/node/JoinDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/node/JoinDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/graph/node/JoinDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,12 +29,13 @@ import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; -import java.io.Writer; -import java.net.URISyntaxException; +import java.io.PrintWriter; +import java.net.URI; import java.net.URL; import java.util.regex.Pattern; import org.hibernate.LockMode; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmException; import org.jbpm.db.AbstractDbTestCase; @@ -47,19 +48,15 @@ */ public class JoinDbTest extends AbstractDbTestCase { - @Override protected JbpmConfiguration getJbpmConfiguration() { if (jbpmConfiguration == null) { URL cfgResource = getClass().getClassLoader().getResource("hibernate.cfg.xml"); try { - OutputStream outStream = new FileOutputStream(new File(cfgResource.toURI().resolve( - "hibernate.join.cfg.xml"))); - sed("Join.hbm.xml", "Join.lock.hbm.xml", cfgResource.openStream(), outStream); + OutputStream outStream = new FileOutputStream(new File(URI.create(cfgResource.toString()) + .resolve("hibernate.join.cfg.xml"))); + sed("Join\\.hbm\\.xml", "Join.lock.hbm.xml", cfgResource.openStream(), outStream); outStream.close(); } - catch (URISyntaxException e) { - throw new AssertionError(e); - } catch (IOException e) { throw new JbpmException("could not edit hibernate configuration", e); } @@ -70,35 +67,32 @@ return jbpmConfiguration; } - @Override protected void tearDown() throws Exception { super.tearDown(); jbpmConfiguration.close(); } - private static void sed(String target, String replacement, InputStream inStream, + private static void sed(String regex, String replacement, InputStream inStream, OutputStream outStream) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(inStream)); - Writer writer = new OutputStreamWriter(outStream); - Pattern pattern = Pattern.compile(target, Pattern.LITERAL); + PrintWriter writer = new PrintWriter(new OutputStreamWriter(outStream)); + Pattern pattern = Pattern.compile(regex); for (String inLine; (inLine = reader.readLine()) != null;) { String outLine = pattern.matcher(inLine).replaceAll(replacement); - writer.write(outLine); - writer.write('\n'); + writer.println(outLine); } reader.close(); writer.flush(); } public void testParentLockMode() { - ProcessDefinition processDefinition = ProcessDefinition - .parseXmlString("<process-definition name='" - + getName() - + "'>" - + " <join name='read' lock='READ' />" - + " <join name='nowait' lock='UPGRADE_NOWAIT' />" - + " <join name='upgrade' lock='pessimistic' />" - + "</process-definition>"); + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='" + + getName() + + "'>" + + " <join name='read' lock='READ' />" + + " <join name='nowait' lock='UPGRADE_NOWAIT' />" + + " <join name='upgrade' lock='pessimistic' />" + + "</process-definition>"); jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1072/JBPM1072Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1072/JBPM1072Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1072/JBPM1072Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -35,7 +35,6 @@ * Concurrent job executors can process the same job in parallel. The test simulates multiple nodes * in the network processing a common job set. The key setting is to give each job executor a * different name; normally, a job executor is named after the node's inet address - * * https://jira.jboss.org/jira/browse/JBPM-1072 * * @author Jiri Pechanec @@ -70,7 +69,6 @@ + " <end-state name='end-state1' />" + "</process-definition>"; - @Override protected void setUp() throws Exception { super.setUp(); @@ -82,7 +80,6 @@ startJobExecutors(); } - @Override protected void tearDown() throws Exception { stopJobExecutors(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1106/JBPM1106Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1106/JBPM1106Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1106/JBPM1106Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -33,18 +33,16 @@ /** * GetProcessInstancesCommand should use Query.setTimestamp instead of Query.setDate - * * https://jira.jboss.org/jira/browse/JBPM-1106 * * @author Alejandro Guizar */ -public class JBPM1106Test extends AbstractDbTestCase -{ +public class JBPM1106Test extends AbstractDbTestCase { + private CommandService commandService = new CommandServiceImpl(getJbpmConfiguration()); private ProcessDefinition processDefinition; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition("Audit"); jbpmContext.deployProcessDefinition(processDefinition); @@ -73,15 +71,12 @@ newTransaction(); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testStartDate() - { + public void testStartDate() { GetProcessInstancesCommand command = new GetProcessInstancesCommand(); Calendar calendar = Calendar.getInstance(); calendar.set(2008, 8, 10, 9, 0); @@ -89,12 +84,11 @@ calendar.add(Calendar.DAY_OF_MONTH, 1); command.setUntilStartDate(calendar.getTime()); - List processInstances = (List)commandService.execute(command); + List processInstances = (List) commandService.execute(command); assertEquals(2, processInstances.size()); } - public void testStartTime() - { + public void testStartTime() { GetProcessInstancesCommand command = new GetProcessInstancesCommand(); Calendar calendar = Calendar.getInstance(); calendar.set(2008, 8, 10, 9, 0); @@ -102,7 +96,7 @@ calendar.set(Calendar.HOUR_OF_DAY, 12); command.setUntilStartDate(calendar.getTime()); - List processInstances = (List)commandService.execute(command); + List processInstances = (List) commandService.execute(command); assertEquals(1, processInstances.size()); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1135/JBPM1135Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1135/JBPM1135Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1135/JBPM1135Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -27,19 +27,16 @@ import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; -/** - * When a timer fires and another timer is created as part of its execution, - * no exception should be thrown. +/** + * When a timer fires and another timer is created as part of its execution, no exception should be + * thrown. https://jira.jboss.org/jira/browse/JBPM-1135 * - * https://jira.jboss.org/jira/browse/JBPM-1135 - * * @author Alejandro Guizar */ public class JBPM1135Test extends AbstractDbTestCase { private long processDefinitionId; - @Override protected void setUp() throws Exception { super.setUp(); @@ -51,7 +48,6 @@ startJobExecutor(); } - @Override protected void tearDown() throws Exception { stopJobExecutor(); graphSession.deleteProcessDefinition(processDefinitionId); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1452/JBPM1452Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1452/JBPM1452Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1452/JBPM1452Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,7 +29,6 @@ /** * JbpmConfiguration assumes the object factory has a jbpm.job.executor entry - * * https://jira.jboss.org/jira/browse/JBPM-1452 * * @author Alejandro Guizar @@ -38,7 +37,6 @@ private long processDefinitionId; - @Override protected JbpmConfiguration getJbpmConfiguration() { if (jbpmConfiguration == null) { jbpmConfiguration = JbpmConfiguration.parseXmlString("<jbpm-configuration>" @@ -48,7 +46,6 @@ return jbpmConfiguration; } - @Override protected void setUp() throws Exception { super.setUp(); ProcessDefinition processDefinition = new ProcessDefinition("Audit"); @@ -56,7 +53,6 @@ processDefinitionId = processDefinition.getId(); } - @Override protected void tearDown() throws Exception { graphSession.deleteProcessDefinition(processDefinitionId); super.tearDown(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1755/JBPM1755Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1755/JBPM1755Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1755/JBPM1755Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,6 +1,7 @@ package org.jbpm.jbpm1755; import org.hibernate.LockMode; + import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.Event; import org.jbpm.graph.def.EventCallback; @@ -10,7 +11,6 @@ /** * Allow process author to set the parent token lock mode in the join token. - * * https://jira.jboss.org/jira/browse/JBPM-1755 * * @author Alejandro Guizar @@ -21,13 +21,11 @@ private static final int processInstanceCount = 5; - @Override protected void setUp() throws Exception { super.setUp(); processDefinition = ProcessDefinition.parseXmlResource("org/jbpm/jbpm1755/parallelprocess.xml"); } - @Override protected void tearDown() throws Exception { graphSession.deleteProcessDefinition(processDefinition.getId()); EventCallback.clear(); @@ -73,7 +71,7 @@ for (int i = 0; i < processInstanceCount; i++) { long processInstanceId = processInstanceIds[i]; - assertTrue("expected process instance " + processInstanceId + " to have ended", + assertTrue("expected process instance " + processInstanceId + " to have ended", jbpmContext.loadProcessInstance(processInstanceId).hasEnded()); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1778/JBPM1778Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1778/JBPM1778Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm1778/JBPM1778Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,6 +1,6 @@ package org.jbpm.jbpm1778; -import java.util.HashMap; +import java.util.Collections; import java.util.Map; import org.jbpm.AbstractJbpmTestCase; @@ -10,18 +10,16 @@ /** * Empty map variables on process creation is set as null - * * https://jira.jboss.org/jira/browse/JBPM-1778 * * @author Thomas.Diesler(a)jboss.com */ -public class JBPM1778Test extends AbstractJbpmTestCase -{ - public void testEmptyMapVariables() - { - ProcessDefinition pd = getProcessDEfinition(); - - ProcessInstance pi = pd.createProcessInstance(new HashMap<String, String>()); +public class JBPM1778Test extends AbstractJbpmTestCase { + + public void testEmptyMapVariables() { + ProcessDefinition pd = getProcessDefinition(); + + ProcessInstance pi = pd.createProcessInstance(Collections.EMPTY_MAP); TaskMgmtInstance tmi = pi.getTaskMgmtInstance(); tmi.createStartTaskInstance(); @@ -30,13 +28,10 @@ assertEquals("ProcessInstance vars empty", 0, piVars.size()); } - public void testNonEmptyMapVariables() - { - ProcessDefinition pd = getProcessDEfinition(); - - HashMap<String, String> vars = new HashMap<String, String>(); - vars.put("uno", "dos"); - + public void testNonEmptyMapVariables() { + ProcessDefinition pd = getProcessDefinition(); + + Map vars = Collections.singletonMap("uno", "dos"); ProcessInstance pi = pd.createProcessInstance(vars); TaskMgmtInstance tmi = pi.getTaskMgmtInstance(); tmi.createStartTaskInstance(); @@ -46,18 +41,16 @@ assertEquals("ProcessInstance vars not empty", 1, piVars.size()); } - private ProcessDefinition getProcessDEfinition() - { - ProcessDefinition pd = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <start-state>" + - " <transition to='s' />" + - " </start-state>" + - " <state name='s'>" + - " <transition to='end' />" + - " </state>" + - " <end-state name='end' />" + - "</process-definition>"); + private ProcessDefinition getProcessDefinition() { + ProcessDefinition pd = ProcessDefinition.parseXmlString("<process-definition>" + + " <start-state>" + + " <transition to='s' />" + + " </start-state>" + + " <state name='s'>" + + " <transition to='end' />" + + " </state>" + + " <end-state name='end' />" + + "</process-definition>"); return pd; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2036/JBPM2036Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2036/JBPM2036Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2036/JBPM2036Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -32,8 +32,10 @@ assertTrue("expected " + processInstance + " to have ended", processInstance.hasEnded()); ContextInstance contextInstance = processInstance.getContextInstance(); - assertEquals(1, contextInstance.getVariable("chaos")); - assertEquals(1, contextInstance.getVariable("undead")); + Integer count = (Integer) contextInstance.getVariable("chaos"); + assertEquals(1, count.intValue()); + count = (Integer) contextInstance.getVariable("undead"); + assertEquals(1, count.intValue()); } finally { graphSession.deleteProcessDefinition(processDefinition.getId()); @@ -67,14 +69,17 @@ } public static class TimerAction implements ActionHandler { + private boolean leave; private static final long serialVersionUID = 1L; + private static final Integer ONE = new Integer(1); public void execute(ExecutionContext executionContext) throws Exception { String timerName = executionContext.getTimer().getName(); - Integer executionCount = (Integer) executionContext.getVariable(timerName); - executionContext.setVariable(timerName, executionCount != null ? executionCount + 1 : 1); + Integer count = (Integer) executionContext.getVariable(timerName); + executionContext.setVariable(timerName, count != null ? new Integer(count.intValue() + 1) + : ONE); if (leave) executionContext.leaveNode(); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/EsbActionHandler.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/EsbActionHandler.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/EsbActionHandler.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,14 +21,15 @@ */ package org.jbpm.jbpm2094; +import java.util.Iterator; import java.util.Random; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.dom4j.Element; + import org.jbpm.graph.def.ActionHandler; import org.jbpm.graph.exe.ExecutionContext; -import org.jbpm.util.CollectionUtil; /** * @author Alejandro Guizar @@ -45,13 +46,15 @@ public void execute(ExecutionContext executionContext) throws Exception { log.debug("simulating invocation of " + esbCategoryName + "::" + esbServiceName); - for (Element bpmToEsbVar : CollectionUtil.checkList(bpmToEsbVars.elements(), Element.class)) { + for (Iterator i = bpmToEsbVars.elementIterator(); i.hasNext();) { + Element bpmToEsbVar = (Element) i.next(); String var = bpmToEsbVar.attributeValue("bpm"); Object value = executionContext.getVariable(var); log.debug("read " + value + " from variable " + var); } Random random = new Random(); - for (Element esbToBpmVar : CollectionUtil.checkList(esbToBpmVars.elements(), Element.class)) { + for (Iterator i = esbToBpmVars.elementIterator(); i.hasNext();) { + Element esbToBpmVar = (Element) i.next(); String var = esbToBpmVar.attributeValue("bpm"); byte[] value = new byte[random.nextInt(2048)]; random.nextBytes(value); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/JBPM2094Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/JBPM2094Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm2094/JBPM2094Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -36,13 +36,11 @@ private static final int TIMEOUT = 60 * 1000; private static final int INSTANCE_COUNT = 5; - @Override protected void setUp() throws Exception { super.setUp(); getJbpmConfiguration().getJobExecutor().setNbrOfThreads(4); } - @Override protected void tearDown() throws Exception { jbpmConfiguration.getJobExecutor().setNbrOfThreads(1); super.tearDown(); @@ -50,10 +48,9 @@ public void testJobExecutorDeadlock() { // Won't fix [JBPM-2094] unindexed foreign keys cause deadlocks in oracle - if (getHibernateDialect().contains("HSQL")) return; + if (getHibernateDialect().indexOf("HSQL") != -1) return; - ProcessDefinition processDefinition = ProcessDefinition - .parseXmlResource("org/jbpm/jbpm2094/processdefinition.xml"); + ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("org/jbpm/jbpm2094/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm983/JBPM983Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm983/JBPM983Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jbpm983/JBPM983Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -5,6 +5,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ActionHandler; import org.jbpm.graph.def.ProcessDefinition; @@ -120,7 +121,7 @@ public void testConcurrentJobs() throws Exception { // Won't Fix [JBPM-983] concurrent process execution fails - if (getHibernateDialect().contains("HSQL")) return; + if (getHibernateDialect().indexOf("HSQL") != -1) return; // create test properties Map testVariables = Collections.singletonMap("test", "true"); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/job/executor/JobExecutorDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/job/executor/JobExecutorDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/job/executor/JobExecutorDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,10 +1,10 @@ package org.jbpm.job.executor; -import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; import java.util.TreeSet; +import java.util.Vector; import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.Action; @@ -18,17 +18,15 @@ static final int nbrOfConcurrentProcessExecutions = 20; static final int timeout = 60000; - static Set<String> collectedResults = Collections.synchronizedSet(new TreeSet<String>()); - static List<Long> allocatedProcessIds = Collections.synchronizedList(new ArrayList<Long>()); + static Set collectedResults = Collections.synchronizedSet(new TreeSet()); + static List allocatedProcessIds = new Vector(); - @Override protected void setUp() throws Exception { super.setUp(); - deployProcess(); + deployProcess(); getJbpmConfiguration().getJobExecutor().setNbrOfThreads(4); } - @Override protected void tearDown() throws Exception { getJbpmConfiguration().getJobExecutor().setNbrOfThreads(1); deleteProcess(); @@ -106,8 +104,8 @@ } } - Set<String> createExpectedResults() { - Set<String> expectedResults = new TreeSet<String>(); + Set createExpectedResults() { + Set expectedResults = new TreeSet(); for (int i = 0; i < nbrOfConcurrentProcessExecutions; i++) { String prefix = (i < 10 ? "0" : ""); expectedResults.add(prefix + i + "a"); @@ -132,7 +130,7 @@ private static final long serialVersionUID = 1L; public void execute(ExecutionContext executionContext) throws Exception { - Long id = executionContext.getProcessInstance().getId(); + long id = executionContext.getProcessInstance().getId(); String procIndex = getProcessIndex(id); String nodeName = executionContext.getNode().getName(); @@ -146,7 +144,7 @@ private static final long serialVersionUID = 1L; public void execute(ExecutionContext executionContext) throws Exception { - Long id = executionContext.getProcessInstance().getId(); + long id = executionContext.getProcessInstance().getId(); String procIndex = getProcessIndex(id); Action action = executionContext.getAction(); @@ -155,13 +153,11 @@ } } - static synchronized String getProcessIndex(Long id) { - if (allocatedProcessIds.contains(id) == false) - allocatedProcessIds.add(id); + static synchronized String getProcessIndex(long id) { + Long identifier = new Long(id); + if (!allocatedProcessIds.contains(identifier)) allocatedProcessIds.add(identifier); - int procIndex = allocatedProcessIds.indexOf(id); - String prefix = (procIndex < 10 ? "0" : ""); - - return prefix + procIndex; + int procIndex = allocatedProcessIds.indexOf(identifier); + return procIndex < 10 ? "0" + procIndex : Integer.toString(procIndex); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/par/ProcessClassLoaderTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/par/ProcessClassLoaderTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/par/ProcessClassLoaderTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -12,20 +12,21 @@ import org.jbpm.util.ClassLoaderUtil; /** - * Test case for ProcessClassLoader hierarchy and setting the ContextClassLoader correctly. + * Test case for ProcessClassLoader hierarchy and setting the ContextClassLoader correctly. Relates + * to {@link ConfigurableClassloadersTest}. * - * Relates to {@link ConfigurableClassloadersTest}. - * - * @author Tom Baeyens, bernd.ruecker(a)camunda.com - * + * @author Tom Baeyens + * @author bernd.ruecker(a)camunda.com */ public class ProcessClassLoaderTest extends AbstractJbpmTestCase { - + public static class TestContextClassLoader extends ClassLoader { + public TestContextClassLoader(ClassLoader parent) { super(parent); } - protected Class< ? > findClass(String name) throws ClassNotFoundException { + + protected Class findClass(String name) throws ClassNotFoundException { if ("TestContextClassLoader-knows-where-to-find-ContextLoadedAction".equals(name)) { return getParent().loadClass(ContextLoadedAction.class.getName()); } @@ -37,8 +38,8 @@ } static int contextLoadedActionInvocations = 0; - static ClassLoader originalClassLoader = null; - + static ClassLoader originalClassLoader = null; + protected void setUp() throws Exception { super.setUp(); contextLoadedActionInvocations = 0; @@ -47,6 +48,8 @@ public static class DefaultLoadedAction implements ActionHandler { + private static final long serialVersionUID = 1L; + public void execute(ExecutionContext executionContext) throws Exception { ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); assertSame(ProcessClassLoader.class, contextClassLoader.getClass()); @@ -57,34 +60,35 @@ contextLoadedActionInvocations++; } } - - /** DOES NOT configure usage of the context classloader. So this tests the default (backwards compatible) behaviour. - * so the classloading hierarchy of DefaultLoadedAction should be - * ProcessClassloader -> jbpm-lib classloader */ + + /** + * DOES NOT configure usage of the context classloader. So this tests the default (backwards + * compatible) behaviour. so the classloading hierarchy of DefaultLoadedAction should be + * ProcessClassloader -> jbpm-lib classloader + */ public void testDefaultClassLoader() { - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <start-state name='start'>" + - " <transition to='state'>" + - " <action class='org.jbpm.jpdl.par.ProcessClassLoaderTest$DefaultLoadedAction' />" + - " </transition>" + - " </start-state>" + - " <state name='state'>" + - " <transition to='end'/>" + - " </state>" + - "</process-definition>" - ); + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <start-state name='start'>" + + " <transition to='state'>" + + " <action class='org.jbpm.jpdl.par.ProcessClassLoaderTest$DefaultLoadedAction' />" + + " </transition>" + + " </start-state>" + + " <state name='state'>" + + " <transition to='end'/>" + + " </state>" + + "</process-definition>"); // create the process instance ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); - - assertEquals(1, contextLoadedActionInvocations); + + assertEquals(1, contextLoadedActionInvocations); } - public static class ContextLoadedAction implements ActionHandler { + private static final long serialVersionUID = 1L; + public void execute(ExecutionContext executionContext) throws Exception { ClassLoader processClassLoader = Thread.currentThread().getContextClassLoader(); assertSame(ProcessClassLoader.class, processClassLoader.getClass()); @@ -98,106 +102,103 @@ } } - /** configures usage of the context classloader - * so the classloading hierarchy of ContextLoadedAction should be - * ProcessClassloader -> TestContextClassLoader -> Thread.currentContextClassLoader */ + /** + * configures usage of the context classloader so the classloading hierarchy of + * ContextLoadedAction should be ProcessClassloader -> TestContextClassLoader -> + * Thread.currentContextClassLoader + */ public void testContextClassLoader() { - - JbpmConfiguration jbpmConfiguration = JbpmConfiguration.parseXmlString( - "<jbpm-configuration>" + - " <string name='jbpm.classLoader' value='context' />" + - "</jbpm-configuration>" - ); - + JbpmConfiguration jbpmConfiguration = JbpmConfiguration.parseXmlString("<jbpm-configuration>" + + " <string name='jbpm.classLoader' value='context' />" + + "</jbpm-configuration>"); + JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); try { - TestContextClassLoader testContextClassLoader = new TestContextClassLoader(originalClassLoader); + TestContextClassLoader testContextClassLoader = new TestContextClassLoader( + originalClassLoader); Thread.currentThread().setContextClassLoader(testContextClassLoader); - - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <start-state name='start'>" + - " <transition to='state'>" + - " <action class='TestContextClassLoader-knows-where-to-find-ContextLoadedAction' />" + - " </transition>" + - " </start-state>" + - " <state name='state'>" + - " <transition to='end'/>" + - " </state>" + - "</process-definition>" - ); - + + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <start-state name='start'>" + + " <transition to='state'>" + + " <action class='TestContextClassLoader-knows-where-to-find-ContextLoadedAction' />" + + " </transition>" + + " </start-state>" + + " <state name='state'>" + + " <transition to='end'/>" + + " </state>" + + "</process-definition>"); + // create the process instance ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); - + assertEquals(1, contextLoadedActionInvocations); assertSame(testContextClassLoader, Thread.currentThread().getContextClassLoader()); - - } finally { + } + finally { Thread.currentThread().setContextClassLoader(originalClassLoader); jbpmContext.close(); } } /** - * a third test should set the testcontextClassLoader in the test and then - * let the action throw an exception. Then it should be verified that the - * original classloader is still restored correctly. Easiest is to start - * from a copy of the testContextClassLoader + * a third test should set the testcontextClassLoader in the test and then let the action throw an + * exception. Then it should be verified that the original classloader is still restored + * correctly. Easiest is to start from a copy of the testContextClassLoader */ public static class ContextLoadedExceptionAction implements ActionHandler { + + private static final long serialVersionUID = 1L; + public void execute(ExecutionContext executionContext) throws Exception { ClassLoader processClassLoader = Thread.currentThread().getContextClassLoader(); assertSame(ProcessClassLoader.class, processClassLoader.getClass()); - + ClassLoader testContextClassLoader = processClassLoader.getParent(); assertSame(TestContextClassLoader.class, testContextClassLoader.getClass()); - + assertSame(originalClassLoader, testContextClassLoader.getParent()); - + contextLoadedActionInvocations++; - + throw new Exception("simulate exception"); } } + public void testContextClassLoaderException() { - JbpmConfiguration jbpmConfiguration = JbpmConfiguration.parseXmlString( - "<jbpm-configuration>" + - " <string name='jbpm.classLoader' value='context' />" + - "</jbpm-configuration>" - ); - + JbpmConfiguration jbpmConfiguration = JbpmConfiguration.parseXmlString("<jbpm-configuration>" + + " <string name='jbpm.classLoader' value='context' />" + + "</jbpm-configuration>"); + JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); TestContextClassLoader testContextClassLoader = new TestContextClassLoader(originalClassLoader); try { Thread.currentThread().setContextClassLoader(testContextClassLoader); - - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <start-state name='start'>" + - " <transition to='state'>" + - " <action class='TestContextClassLoader-knows-where-to-find-ContextLoadedExceptionAction' />" + - " </transition>" + - " </start-state>" + - " <state name='state'>" + - " <transition to='end'/>" + - " </state>" + - "</process-definition>" - ); - + + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <start-state name='start'>" + + " <transition to='state'>" + + " <action class='TestContextClassLoader-knows-where-to-find-ContextLoadedExceptionAction' />" + + " </transition>" + + " </start-state>" + + " <state name='state'>" + + " <transition to='end'/>" + + " </state>" + + "</process-definition>"); + // create the process instance ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); - - } catch(Exception ex) { + } + catch (Exception ex) { assertEquals(1, contextLoadedActionInvocations); assertEquals("simulate exception", ex.getMessage()); assertSame(testContextClassLoader, Thread.currentThread().getContextClassLoader()); - - } finally { + } + finally { Thread.currentThread().setContextClassLoader(originalClassLoader); jbpmContext.close(); } - } + } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/xml/AbstractXmlTestCase.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/xml/AbstractXmlTestCase.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/jpdl/xml/AbstractXmlTestCase.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -22,7 +22,7 @@ package org.jbpm.jpdl.xml; import java.io.StringWriter; -import java.util.HashMap; +import java.util.Collections; import org.dom4j.DocumentHelper; import org.dom4j.Element; @@ -31,46 +31,36 @@ import org.jbpm.graph.def.ProcessDefinition; public abstract class AbstractXmlTestCase extends AbstractJbpmTestCase { - - // private static final String JPDL_NAMESPACE = "http://jbpm.org/3/jpdl"; - static Element toXmlAndParse(ProcessDefinition processDefinition, String xpathExpression) throws Exception { + static Element toXmlAndParse(ProcessDefinition processDefinition, String xpathExpression) + throws Exception { Element element = toXmlAndParse(processDefinition); return (Element) element.selectSingleNode(xpathExpression); } - - static Element toXmlAndParse(ProcessDefinition processDefinition, String xpathExpression, String namespace) throws Exception { - Element element = toXmlAndParseWithNamespace(processDefinition); - XPath xpath = DocumentHelper.createXPath(xpathExpression); - HashMap m = new HashMap(); - m.put("", namespace); - - xpath.setNamespaceURIs( m ); - return (Element) xpath.selectSingleNode( element ); - } + static Element toXmlAndParse(ProcessDefinition processDefinition, String xpathExpression, + String namespace) throws Exception { + Element element = toXmlAndParseWithNamespace(processDefinition); + XPath xpath = DocumentHelper.createXPath(xpathExpression); + xpath.setNamespaceURIs(Collections.singletonMap("", namespace)); + return (Element) xpath.selectSingleNode(element); + } static Element toXmlAndParse(ProcessDefinition processDefinition) throws Exception { + String xml = JpdlXmlWriter.toString(processDefinition); + return DocumentHelper.parseText(xml).getRootElement(); + } + + static Element toXmlAndParseWithNamespace(ProcessDefinition processDefinition) throws Exception { StringWriter stringWriter = new StringWriter(); JpdlXmlWriter jpdlWriter = new JpdlXmlWriter(stringWriter); - jpdlWriter.write( processDefinition ); + jpdlWriter.setUseNamespace(true); + jpdlWriter.write(processDefinition); String xml = stringWriter.toString(); - return DocumentHelper.parseText( xml ).getRootElement(); + return DocumentHelper.parseText(xml).getRootElement(); } - - static Element toXmlAndParseWithNamespace(ProcessDefinition processDefinition) throws Exception { - StringWriter stringWriter = new StringWriter(); - JpdlXmlWriter jpdlWriter = new JpdlXmlWriter(stringWriter); - jpdlWriter.setUseNamespace( true ); - jpdlWriter.write( processDefinition ); - String xml = stringWriter.toString(); - return DocumentHelper.parseText( xml ).getRootElement(); - } - + static void printXml(ProcessDefinition processDefinition) { - StringWriter stringWriter = new StringWriter(); - JpdlXmlWriter jpdlWriter = new JpdlXmlWriter(stringWriter); - jpdlWriter.write( processDefinition ); - // System.out.println( stringWriter.toString() ); + System.out.println(JpdlXmlWriter.toString(processDefinition)); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/logging/exe/LoggingConfigDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/logging/exe/LoggingConfigDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/logging/exe/LoggingConfigDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,6 +1,7 @@ package org.jbpm.logging.exe; import org.hibernate.Query; + import org.jbpm.JbpmConfiguration; import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ProcessDefinition; @@ -8,7 +9,6 @@ public class LoggingConfigDbTest extends AbstractDbTestCase { - @Override protected JbpmConfiguration getJbpmConfiguration() { if (jbpmConfiguration == null) { jbpmConfiguration = JbpmConfiguration.parseResource("org/jbpm/logging/exe/nologging.jbpm.cfg.xml"); @@ -16,7 +16,6 @@ return jbpmConfiguration; } - @Override protected void tearDown() throws Exception { super.tearDown(); jbpmConfiguration.close(); Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,159 +0,0 @@ -package org.jbpm.optimisticlocking; - -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; -import java.util.concurrent.Semaphore; - -import org.hibernate.Query; -import org.jbpm.JbpmConfiguration; -import org.jbpm.JbpmContext; -import org.jbpm.db.AbstractDbTestCase; -import org.jbpm.graph.def.ProcessDefinition; -import org.jbpm.graph.exe.Comment; -import org.jbpm.graph.exe.ProcessInstance; - -/** - * Possible problem in concurrent signalling from multiple threads - * - * https://jira.jboss.org/jira/browse/JBPM-1071 - */ -public class LockingTest extends AbstractDbTestCase { - - private long processDefinitionId; - - static final int nbrOfThreads = 5; - static final int nbrOfIterations = 20; - - protected void setUp() throws Exception { - super.setUp(); - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='lockprocess'>" - + " <start-state name='start'>" - + " <transition to='end'/>" - + " </start-state>" - + " <end-state name='end' />" - + "</process-definition>"); - jbpmContext.deployProcessDefinition(processDefinition); - newTransaction(); - processDefinitionId = processDefinition.getId(); - } - - protected void tearDown() throws Exception { - graphSession.deleteProcessDefinition(processDefinitionId); - super.tearDown(); - } - - public void testLocking() { - // the process will be executed in 2 separate transactions: - // Transaction 1 will create the process instance and position - // the root token in the start state - // Transaction 2 will signal the process instance while it is in the - // start state, and that signal will bring the process to it's end state. - // multiple competing threads will be set up for the second transaction - - ProcessDefinition processDefinition = graphSession.loadProcessDefinition(processDefinitionId); - for (int i = 0; i < nbrOfIterations; i++) { - ProcessInstance processInstance = new ProcessInstance(processDefinition); - jbpmContext.save(processInstance); - - newTransaction(); - - // create a bunch of threads that will all wait on the - // semaphore before they will try to signal the same process instance - long processInstanceId = processInstance.getId(); - Semaphore semaphore = new Semaphore(0); - List threads = startThreads(semaphore, processInstanceId); - - // release all the threads - semaphore.release(nbrOfThreads); - - // wait for all threads to finish - joinAllThreads(threads); - - // check that only 1 of those threads committed - Query query = session.createQuery("from org.jbpm.graph.exe.Comment"); - List results = query.list(); - assertEquals(results.toString(), 1, results.size()); - - // delete the comment - session.delete(results.get(0)); - - // check that the process instance has ended - processInstance = jbpmContext.loadProcessInstance(processInstanceId); - assertTrue(processInstance.hasEnded()); - } - } - - private List startThreads(Semaphore semaphore, long processInstanceId) { - JbpmConfiguration jbpmConfiguration = getJbpmConfiguration(); - - List threads = new ArrayList(); - for (int i = 0; i < nbrOfThreads; i++) { - Thread thread = new LockThread(jbpmConfiguration, semaphore, processInstanceId); - threads.add(thread); - thread.start(); - } - return threads; - } - - private void joinAllThreads(List threads) { - Iterator iter = threads.iterator(); - while (iter.hasNext()) { - Thread thread = (Thread) iter.next(); - try { - thread.join(10000); - } - catch (InterruptedException e) { - fail("join interrupted"); - } - } - } - - static class LockThread extends Thread { - - Semaphore semaphore; - long processInstanceId; - JbpmConfiguration jbpmConfiguration; - - public LockThread(JbpmConfiguration jbpmConfiguration, Semaphore semaphore, long processInstanceId) { - this.semaphore = semaphore; - this.processInstanceId = processInstanceId; - this.jbpmConfiguration = jbpmConfiguration; - } - - public void run() { - try { - // first wait until the all threads are released at once in the - // method testLocking - semaphore.acquire(); - - // after a thread is released (=notified), it will try to load the - // process instance, - // signal it and then commit the transaction - JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try { - ProcessInstance processInstance = jbpmContext.loadProcessInstance(processInstanceId); - processInstance.signal(); - jbpmContext.save(processInstance); - - // add a comment in the same transaction so that we can see which - // thread won - Comment comment = new Comment(getName() + " committed"); - jbpmContext.getSession().save(comment); - } - catch (RuntimeException e) { - jbpmContext.setRollbackOnly(); - } - finally { - jbpmContext.close(); - } - } - catch (InterruptedException e) { - fail("semaphore waiting got interrupted"); - } - catch (RuntimeException e) { - // ignore other exceptions - } - } - } -} Copied: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java (from rev 4691, jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java) =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/optimisticlocking/LockingTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,161 @@ +package org.jbpm.optimisticlocking; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.jbpm.JbpmContext; +import org.jbpm.db.AbstractDbTestCase; +import org.jbpm.graph.def.ProcessDefinition; +import org.jbpm.graph.exe.Comment; +import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.persistence.JbpmPersistenceException; +import org.jbpm.persistence.db.StaleObjectLogConfigurer; +import org.jbpm.svc.Services; +import org.jbpm.util.Semaphore; + +/** + * Possible problem in concurrent signalling from multiple threads + * https://jira.jboss.org/jira/browse/JBPM-1071 + */ +public class LockingTest extends AbstractDbTestCase { + + private long processDefinitionId; + + static final int nbrOfThreads = 4; + static final int nbrOfIterations = 20; + + protected void setUp() throws Exception { + super.setUp(); + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='lockprocess'>" + + " <start-state name='start'>" + + " <transition to='end'/>" + + " </start-state>" + + " <end-state name='end' />" + + "</process-definition>"); + jbpmContext.deployProcessDefinition(processDefinition); + newTransaction(); + processDefinitionId = processDefinition.getId(); + } + + protected void tearDown() throws Exception { + graphSession.deleteProcessDefinition(processDefinitionId); + super.tearDown(); + } + + public void testLocking() { + // the process will be executed in 2 separate transactions: + // Transaction 1 will create the process instance and position + // the root token in the start state + // Transaction 2 will signal the process instance while it is in the + // start state, and that signal will bring the process to it's end state. + // multiple competing threads will be set up for the second transaction + + ProcessDefinition processDefinition = graphSession.loadProcessDefinition(processDefinitionId); + for (int i = 0; i < nbrOfIterations; i++) { + ProcessInstance processInstance = new ProcessInstance(processDefinition); + jbpmContext.save(processInstance); + + newTransaction(); + + // create a bunch of threads that will all wait on the + // semaphore before they will try to signal the same process instance + long processInstanceId = processInstance.getId(); + Semaphore semaphore = new Semaphore(0); + List threads = startThreads(semaphore, processInstanceId); + + // release all the threads + semaphore.release(nbrOfThreads); + + // wait for all threads to finish + joinAllThreads(threads); + + // check that only 1 of those threads committed + List results = session.createCriteria(Comment.class).list(); + assertEquals(results.toString(), 1, results.size()); + + // delete the comment + session.delete(results.get(0)); + + // check that the process instance has ended + processInstance = jbpmContext.loadProcessInstance(processInstanceId); + assertTrue(processInstance.hasEnded()); + } + } + + private List startThreads(Semaphore semaphore, long processInstanceId) { + List threads = new ArrayList(); + for (int i = 0; i < nbrOfThreads; i++) { + Thread thread = new LockThread(semaphore, processInstanceId); + threads.add(thread); + thread.start(); + } + return threads; + } + + private void joinAllThreads(List threads) { + for (Iterator i = threads.iterator(); i.hasNext();) { + Thread thread = (Thread) i.next(); + try { + thread.join(10000); + } + catch (InterruptedException e) { + fail("join interrupted"); + } + } + } + + class LockThread extends Thread { + + final Semaphore semaphore; + final long processInstanceId; + + public LockThread(Semaphore semaphore, long processInstanceId) { + this.semaphore = semaphore; + this.processInstanceId = processInstanceId; + } + + public void run() { + try { + // first wait until the all threads are released at once in the + // method testLocking + semaphore.acquire(); + } + catch (InterruptedException e) { + fail("semaphore waiting got interrupted"); + } + + // after a thread is released (=notified), it will try to load the process instance, + // signal it and then commit the transaction + JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); + try { + ProcessInstance processInstance = jbpmContext.loadProcessInstance(processInstanceId); + processInstance.signal(); + jbpmContext.save(processInstance); + + // add a comment in the same transaction so that we can see which thread won + Comment comment = new Comment(getName() + " committed"); + jbpmContext.getSession().save(comment); + } + catch (RuntimeException e) { + jbpmContext.setRollbackOnly(); + throw e; + } + finally { + try { + jbpmContext.close(); + } + catch (JbpmPersistenceException e) { + // if this is a stale object exception, keep it quiet + if (Services.isCausedByStaleState(e)) { + StaleObjectLogConfigurer.getStaleObjectExceptionsLog() + .error(getName() + " rolled back"); + } + else { + throw e; + } + } + } + } + } +} Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/SimplePerformanceTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/SimplePerformanceTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/SimplePerformanceTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,13 +21,12 @@ */ package org.jbpm.perf; -import java.util.concurrent.Semaphore; - import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ActionHandler; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ExecutionContext; import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.util.Semaphore; /** * This test creates a number of process instances. Every instance has a call to an ActionHandler. @@ -47,7 +46,6 @@ private ProcessDefinition processDefinition; - @Override protected void setUp() throws Exception { super.setUp(); @@ -68,7 +66,6 @@ startJobExecutor(); } - @Override protected void tearDown() throws Exception { stopJobExecutor(); @@ -118,6 +115,7 @@ } public static class AsyncSignalAction implements ActionHandler { + private static final long serialVersionUID = -8617329370138396271L; public void execute(final ExecutionContext executionContext) throws Exception { Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/TaskWithVariablesTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/TaskWithVariablesTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/perf/TaskWithVariablesTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -25,6 +25,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.context.exe.ContextInstance; import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ProcessDefinition; @@ -34,55 +35,47 @@ import org.jbpm.taskmgmt.exe.Assignable; import org.jbpm.taskmgmt.exe.TaskInstance; -public class TaskWithVariablesTest extends AbstractDbTestCase -{ +public class TaskWithVariablesTest extends AbstractDbTestCase { - public static class ErnieAssignmentHandler implements AssignmentHandler - { + public static class ErnieAssignmentHandler implements AssignmentHandler { + private static final long serialVersionUID = 1L; - public void assign(Assignable assignable, ExecutionContext executionContext) throws Exception - { + public void assign(Assignable assignable, ExecutionContext executionContext) throws Exception { assignable.setActorId("manager"); } } - + ProcessDefinition processDefinition; - - @Override - protected void setUp() throws Exception - { + + protected void setUp() throws Exception { super.setUp(); - processDefinition = ProcessDefinition.parseXmlString( - "<process-definition name='states'>" + - " <start-state>" + - " <transition to='one' />" + - " </start-state>" + - " <task-node name='one'>" + - " <task name='one'>" + - " <assignment class='org.jbpm.perf.TaskWithVariablesTest$ErnieAssignmentHandler' />" + - " </task>" + - " <transition to='two' />" + - " </task-node>" + - " <task-node name='two'>" + - " <task name='two'>" + - " <assignment class='org.jbpm.perf.TaskWithVariablesTest$ErnieAssignmentHandler' />" + - " </task>" + - " <transition to='end' />" + - " </task-node>" + - " <end-state name='end' />" + - "</process-definition>" - ); + processDefinition = ProcessDefinition.parseXmlString("<process-definition name='states'>" + + " <start-state>" + + " <transition to='one' />" + + " </start-state>" + + " <task-node name='one'>" + + " <task name='one'>" + + " <assignment class='org.jbpm.perf.TaskWithVariablesTest$ErnieAssignmentHandler' />" + + " </task>" + + " <transition to='two' />" + + " </task-node>" + + " <task-node name='two'>" + + " <task name='two'>" + + " <assignment class='org.jbpm.perf.TaskWithVariablesTest$ErnieAssignmentHandler' />" + + " </task>" + + " <transition to='end' />" + + " </task-node>" + + " <end-state name='end' />" + + "</process-definition>"); processDefinition = saveAndReload(processDefinition); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - + public void testStates() { log.info(""); log.info("=== CREATING PROCESS INSTANCE ======================================================="); @@ -97,7 +90,7 @@ processInstance.signal(); newTransaction(); - + log.info(""); log.info("=== PERFORMING TASK ONE ======================================================="); log.info(""); @@ -108,7 +101,7 @@ taskInstance.end(); newTransaction(); - + log.info(""); log.info("=== PERFORMING TASK TWO ======================================================="); log.info(""); @@ -118,6 +111,6 @@ taskInstance.setVariable("delivery address", "829 maple street"); taskInstance.end(); } - + private static final Log log = LogFactory.getLog(TaskWithVariablesTest.class); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/seam/JobExecutorCustomizationTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/seam/JobExecutorCustomizationTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/seam/JobExecutorCustomizationTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -7,16 +7,14 @@ import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.job.executor.JobExecutor; +public class JobExecutorCustomizationTest extends AbstractDbTestCase { -public class JobExecutorCustomizationTest extends AbstractDbTestCase { - public static List jobEvents = new ArrayList(); - + protected String getJbpmTestConfig() { return "org/jbpm/seam/custom.job.executor.jbpm.cfg.xml"; } - @Override protected void tearDown() throws Exception { super.tearDown(); jbpmConfiguration.close(); @@ -25,45 +23,47 @@ public void testCustomJobExecutor() { JobExecutor jobExecutor = getJbpmConfiguration().getJobExecutor(); assertEquals(CustomJobExecutor.class, jobExecutor.getClass()); - - ProcessDefinition processDefinition = ProcessDefinition.parseXmlString( - "<process-definition name='customjobexecution' initial='start'>" + - " <node name='start'>" + - " <transition to='end'>" + - " <action async='true' class='"+AsyncAction.class.getName()+"' />" + - " </transition>" + - " </node>" + - " <state name='end' />" + - "</process-definition>" - ); + + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='customjobexecution' initial='start'>" + + " <node name='start'>" + + " <transition to='end'>" + + " <action async='true' class='" + + AsyncAction.class.getName() + + "' />" + + " </transition>" + + " </node>" + + " <state name='end' />" + + "</process-definition>"); jbpmContext.deployProcessDefinition(processDefinition); long processDefinitionId = processDefinition.getId(); try { - + newTransaction(); - + jbpmContext.newProcessInstanceForUpdate("customjobexecution"); - + newTransaction(); - + jobExecutor.start(); try { waitForJobs(20000); - } finally { + } + finally { jobExecutor.stop(); } - } finally { + } + finally { newTransaction(); - + graphSession.deleteProcessDefinition(processDefinitionId); } - + List expectedJobEvents = new ArrayList(); expectedJobEvents.add("before"); expectedJobEvents.add("execute action"); expectedJobEvents.add("after"); - + assertEquals(expectedJobEvents, jobEvents); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/SwimlaneDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/SwimlaneDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/SwimlaneDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -33,10 +33,10 @@ Swimlane buyer; Task laundry; Task dishes; - + protected void setUp() throws Exception { super.setUp(); - + processDefinition = new ProcessDefinition(); taskMgmtDefinition = new TaskMgmtDefinition(); processDefinition.addDefinition(taskMgmtDefinition); @@ -44,10 +44,8 @@ laundry = new Task("laundry"); dishes = new Task("dishes"); } - - @Override - protected void tearDown() throws Exception - { + + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } @@ -55,11 +53,11 @@ public void testSwimlaneAddTask() { buyer.addTask(laundry); buyer.addTask(dishes); - + processDefinition = saveAndReload(processDefinition); taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); - - assertEquals(2,buyer.getTasks().size()); + + assertEquals(2, buyer.getTasks().size()); assertTrue(buyer.getTasks().contains(laundry)); assertTrue(buyer.getTasks().contains(dishes)); } @@ -67,42 +65,40 @@ public void testSwimlaneAddTaskInverseReference() { buyer.addTask(laundry); buyer.addTask(dishes); - + processDefinition = saveAndReload(processDefinition); taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); - + assertSame(buyer, laundry.getSwimlane()); assertSame(buyer, dishes.getSwimlane()); } - + public void testTriangularRelation() { buyer.addTask(laundry); taskMgmtDefinition.addTask(laundry); taskMgmtDefinition.addSwimlane(buyer); - + processDefinition = saveAndReload(processDefinition); taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); laundry = taskMgmtDefinition.getTask("laundry"); - assertEquals(1,taskMgmtDefinition.getTasks().size()); - assertEquals(1,buyer.getTasks().size()); + assertEquals(1, taskMgmtDefinition.getTasks().size()); + assertEquals(1, buyer.getTasks().size()); assertEquals("laundry", laundry.getName()); assertSame(laundry, taskMgmtDefinition.getSwimlane("buyer").getTasks().iterator().next()); assertSame(taskMgmtDefinition, laundry.getTaskMgmtDefinition()); assertSame(taskMgmtDefinition.getSwimlane("buyer"), laundry.getSwimlane()); } - + public void testSwimlaneAssignment() { - processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <swimlane name='boss'>" + - " <assignment class='org.jbpm.TheOneAndOnly' />" + - " </swimlane>" + - "</process-definition>" - ); - + processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <swimlane name='boss'>" + + " <assignment class='org.jbpm.TheOneAndOnly' />" + + " </swimlane>" + + "</process-definition>"); + processDefinition = saveAndReload(processDefinition); - + taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); Swimlane boss = taskMgmtDefinition.getSwimlane("boss"); assertNotNull(boss); @@ -114,16 +110,14 @@ } public void testSwimlaneTaskMgmtTest() { - processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <swimlane name='boss'>" + - " <assignment class='org.jbpm.TheOneAndOnly' />" + - " </swimlane>" + - "</process-definition>" - ); - + processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <swimlane name='boss'>" + + " <assignment class='org.jbpm.TheOneAndOnly' />" + + " </swimlane>" + + "</process-definition>"); + processDefinition = saveAndReload(processDefinition); - + taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); Swimlane boss = taskMgmtDefinition.getSwimlane("boss"); assertNotNull(boss); @@ -131,26 +125,24 @@ } public void testTaskToSwimlane() { - processDefinition = ProcessDefinition.parseXmlString( - "<process-definition>" + - " <swimlane name='boss'>" + - " <assignment class='org.jbpm.TheOneAndOnly' />" + - " </swimlane>" + - " <task-node name='work'>" + - " <task name='manage' swimlane='boss' />" + - " </task-node>" + - "</process-definition>" - ); - + processDefinition = ProcessDefinition.parseXmlString("<process-definition>" + + " <swimlane name='boss'>" + + " <assignment class='org.jbpm.TheOneAndOnly' />" + + " </swimlane>" + + " <task-node name='work'>" + + " <task name='manage' swimlane='boss' />" + + " </task-node>" + + "</process-definition>"); + processDefinition = saveAndReload(processDefinition); - + taskMgmtDefinition = processDefinition.getTaskMgmtDefinition(); - + TaskNode work = (TaskNode) processDefinition.getNode("work"); Task manage = work.getTask("manage"); assertNotNull(manage); assertSame(taskMgmtDefinition.getTask("manage"), manage); - + assertNotNull(manage.getSwimlane()); assertSame(taskMgmtDefinition.getSwimlane("boss"), manage.getSwimlane()); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/TaskMgmtDefinitionDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/TaskMgmtDefinitionDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/def/TaskMgmtDefinitionDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -24,8 +24,7 @@ import org.jbpm.db.AbstractDbTestCase; import org.jbpm.graph.def.ProcessDefinition; -public class TaskMgmtDefinitionDbTest extends AbstractDbTestCase -{ +public class TaskMgmtDefinitionDbTest extends AbstractDbTestCase { ProcessDefinition processDefinition; TaskMgmtDefinition taskMgmtDefinition; @@ -34,8 +33,7 @@ Task laundry; Task dishes; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition(); @@ -47,15 +45,12 @@ dishes = new Task("dishes"); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testTaskMgmtDefinitionAddSwimlanes() - { + public void testTaskMgmtDefinitionAddSwimlanes() { taskMgmtDefinition.addSwimlane(buyer); taskMgmtDefinition.addSwimlane(seller); @@ -67,8 +62,7 @@ assertEquals("seller", taskMgmtDefinition.getSwimlane("seller").getName()); } - public void testTaskMgmtDefinitionAddSwimlaneInverseReference() - { + public void testTaskMgmtDefinitionAddSwimlaneInverseReference() { taskMgmtDefinition.addSwimlane(buyer); taskMgmtDefinition.addSwimlane(seller); @@ -79,8 +73,7 @@ assertSame(taskMgmtDefinition, taskMgmtDefinition.getSwimlane("seller").getTaskMgmtDefinition()); } - public void testTaskMgmtDefinitionAddTasks() - { + public void testTaskMgmtDefinitionAddTasks() { taskMgmtDefinition.addTask(laundry); taskMgmtDefinition.addTask(dishes); @@ -92,8 +85,7 @@ assertEquals("dishes", taskMgmtDefinition.getTask("dishes").getName()); } - public void testTaskMgmtDefinitionAddTasksInverseReference() - { + public void testTaskMgmtDefinitionAddTasksInverseReference() { taskMgmtDefinition.addTask(laundry); taskMgmtDefinition.addTask(dishes); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskMgmtInstanceDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskMgmtInstanceDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskMgmtInstanceDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,8 +30,7 @@ import org.jbpm.taskmgmt.def.Task; import org.jbpm.taskmgmt.def.TaskMgmtDefinition; -public class TaskMgmtInstanceDbTest extends AbstractDbTestCase -{ +public class TaskMgmtInstanceDbTest extends AbstractDbTestCase { ProcessDefinition processDefinition; TaskMgmtDefinition taskMgmtDefinition; @@ -43,8 +42,7 @@ ProcessInstance processInstance; TaskMgmtInstance taskMgmtInstance; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); processDefinition = new ProcessDefinition(); @@ -73,15 +71,12 @@ taskMgmtInstance = processInstance.getTaskMgmtInstance(); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); super.tearDown(); } - public void testTaskMgmtInstanceTaskInstances() - { + public void testTaskMgmtInstanceTaskInstances() { taskMgmtInstance.createTaskInstance(laundry, processInstance.getRootToken()); taskMgmtInstance.createTaskInstance(dishes, processInstance.getRootToken()); @@ -90,8 +85,7 @@ assertEquals(2, taskMgmtInstance.getTaskInstances().size()); } - public void testTaskMgmtInstanceSwimlaneInstances() - { + public void testTaskMgmtInstanceSwimlaneInstances() { SwimlaneInstance swimlaneInstance = taskMgmtInstance.createSwimlaneInstance(buyer); swimlaneInstance.setActorId("john doe"); @@ -104,12 +98,11 @@ assertEquals(2, taskMgmtInstance.getSwimlaneInstances().size()); } - public static class MultipleAssignmentHandler implements AssignmentHandler - { + public static class MultipleAssignmentHandler implements AssignmentHandler { + private static final long serialVersionUID = 1L; - public void assign(Assignable assignable, ExecutionContext executionContext) throws Exception - { + public void assign(Assignable assignable, ExecutionContext executionContext) throws Exception { assignable.setPooledActors(new String[] { "me", "you", "them" }); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskTimerExecutionDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskTimerExecutionDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskTimerExecutionDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -37,6 +37,7 @@ static int counter = 0; public static class PlusPlus implements ActionHandler { + private static final long serialVersionUID = 1L; public void execute(ExecutionContext executionContext) throws Exception { @@ -102,11 +103,11 @@ newTransaction(); - List<TaskInstance> taskInstances = taskMgmtSession.findTaskInstancesByToken(processInstance.getRootToken() + List taskInstances = taskMgmtSession.findTaskInstancesByToken(processInstance.getRootToken() .getId()); assertEquals(1, taskInstances.size()); - TaskInstance taskInstance = taskInstances.get(0); + TaskInstance taskInstance = (TaskInstance) taskInstances.get(0); taskInstance.end(); jbpmContext.save(taskInstance); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskVariablesDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskVariablesDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/exe/TaskVariablesDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,17 +29,15 @@ import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; -public class TaskVariablesDbTest extends AbstractDbTestCase -{ - public void testDefaultVariablePersistence() - { +public class TaskVariablesDbTest extends AbstractDbTestCase { + + public void testDefaultVariablePersistence() { ProcessDefinition processDefinition = ProcessDefinition.createNewProcessDefinition(); processDefinition.setName("default variable persistence"); jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); TaskInstance taskInstance = processInstance.getTaskMgmtInstance().createTaskInstance( processInstance.getRootToken()); @@ -49,14 +47,12 @@ assertNotNull(taskInstance); assertEquals("value", taskInstance.getVariable("key")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testSetOnTaskInstanceGetOnProcess() - { + public void testSetOnTaskInstanceGetOnProcess() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='set on task get on process'>" + " <start-state>" + " <transition to='t' />" @@ -68,19 +64,18 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); processInstance = saveAndReload(processInstance); ContextInstance contextInstance = processInstance.getContextInstance(); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); - Map<String, Object> expectedVariables = new HashMap<String, Object>(); + Map expectedVariables = new HashMap(); assertEquals(expectedVariables, taskInstance.getVariables()); assertFalse(taskInstance.hasVariable("a")); @@ -99,14 +94,12 @@ assertEquals("1", taskInstance.getVariable("a")); assertEquals("1", contextInstance.getVariable("a")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testSetOnProcessGetOnTaskInstance() - { + public void testSetOnProcessGetOnTaskInstance() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='set on process get on task'>" + " <start-state>" + " <transition to='t' />" @@ -118,21 +111,20 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); processInstance = saveAndReload(processInstance); ContextInstance contextInstance = processInstance.getContextInstance(); contextInstance.setVariable("a", "1"); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); taskInstance = saveAndReload(taskInstance); - Map<String, Object> expectedVariables = new HashMap<String, Object>(); + Map expectedVariables = new HashMap(); expectedVariables.put("a", "1"); assertEquals(expectedVariables, taskInstance.getVariables()); @@ -143,14 +135,12 @@ assertEquals("1", taskInstance.getVariable("a")); assertEquals("1", contextInstance.getVariable("a")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testSetLocally() - { + public void testSetLocally() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='set locally'>" + " <start-state>" + " <transition to='t' />" @@ -162,11 +152,10 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); @@ -174,7 +163,7 @@ taskInstance = saveAndReload(taskInstance); ContextInstance contextInstance = taskInstance.getContextInstance(); - Map<String, Object> expectedVariables = new HashMap<String, Object>(); + Map expectedVariables = new HashMap(); assertEquals(expectedVariables, taskInstance.getVariables()); assertFalse(taskInstance.hasVariable("a")); assertNull(taskInstance.getVariable("a")); @@ -192,14 +181,12 @@ assertEquals("1", taskInstance.getVariable("a")); assertNull(contextInstance.getVariable("a")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testCopyWithController() - { + public void testCopyWithController() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='copy with controller'>" + " <start-state>" + " <transition to='t' />" @@ -216,8 +203,7 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); ContextInstance contextInstance = processInstance.getContextInstance(); contextInstance.setVariable("a", "1"); @@ -225,14 +211,14 @@ contextInstance.setVariable("c", "3"); processInstance.signal(); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); taskInstance = saveAndReload(taskInstance); - Map<String, Object> expectedVariables = new HashMap<String, Object>(); + Map expectedVariables = new HashMap(); expectedVariables.put("a", "1"); expectedVariables.put("b", "2"); expectedVariables.put("c", "3"); @@ -259,14 +245,12 @@ expectedVariables.put("c", "3 modified"); assertEquals(expectedVariables, contextInstance.getVariables()); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testOverwriteNullValue() - { + public void testOverwriteNullValue() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='overwrite-null-value'>" + " <start-state>" + " <transition to='t' />" @@ -282,13 +266,12 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); processInstance = saveAndReload(processInstance); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); @@ -299,14 +282,12 @@ taskInstance = saveAndReload(taskInstance); assertEquals("facelets is great", taskInstance.getVariable("v")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } - public void testNewTaskInstanceVariablesWithoutController() - { + public void testNewTaskInstanceVariablesWithoutController() { ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='task variables without controller'>" + " <start-state>" + " <transition to='t' />" @@ -320,12 +301,11 @@ jbpmContext.deployProcessDefinition(processDefinition); newTransaction(); - try - { + try { ProcessInstance processInstance = new ProcessInstance(processDefinition); processInstance.signal(); - TaskInstance taskInstance = processInstance.getTaskMgmtInstance() + TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance() .getTaskInstances() .iterator() .next(); @@ -352,8 +332,7 @@ assertEquals("value-a", contextInstance.getVariable("a")); assertEquals("value-b", contextInstance.getVariable("b")); } - finally - { + finally { jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId()); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/log/SwimlaneLogDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/log/SwimlaneLogDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/java/org/jbpm/taskmgmt/log/SwimlaneLogDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -24,46 +24,40 @@ import org.jbpm.db.AbstractDbTestCase; import org.jbpm.taskmgmt.exe.SwimlaneInstance; -public class SwimlaneLogDbTest extends AbstractDbTestCase -{ +public class SwimlaneLogDbTest extends AbstractDbTestCase { SwimlaneInstance swimlaneInstance = null; - protected void setUp() throws Exception - { + protected void setUp() throws Exception { super.setUp(); swimlaneInstance = new SwimlaneInstance(); session.save(swimlaneInstance); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { session.delete(swimlaneInstance); super.tearDown(); } - public void testSwimlaneCreateLog() - { + public void testSwimlaneCreateLog() { SwimlaneCreateLog slLog = new SwimlaneCreateLog(swimlaneInstance, "you"); session.save(slLog); newTransaction(); - slLog = (SwimlaneCreateLog)session.load(SwimlaneCreateLog.class, new Long(slLog.getId())); + slLog = (SwimlaneCreateLog) session.load(SwimlaneCreateLog.class, new Long(slLog.getId())); assertNotNull(slLog); assertNotNull(slLog.getSwimlaneInstance()); session.delete(slLog); } - public void testSwimlaneAssignLog() - { + public void testSwimlaneAssignLog() { SwimlaneAssignLog slLog = new SwimlaneAssignLog(swimlaneInstance, "me", "toyou"); session.save(slLog); newTransaction(); - slLog = (SwimlaneAssignLog)session.load(SwimlaneAssignLog.class, new Long(slLog.getId())); + slLog = (SwimlaneAssignLog) session.load(SwimlaneAssignLog.class, new Long(slLog.getId())); assertNotNull(slLog); assertNotNull(slLog.getSwimlaneInstance()); assertEquals("me", (slLog.getSwimlaneOldActorId())); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/core/src/test/resources/org/jbpm/context/exe/CustomSerializable.zip =================================================================== (Binary files differ) Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/db/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/db/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/db/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,7 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<classpath> - <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> - <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> - <classpathentry kind="output" path="target/classes"/> -</classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/db/.project =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/db/.project 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/db/.project 2009-05-04 09:33:28 UTC (rev 4706) @@ -6,18 +6,12 @@ </projects> <buildSpec> <buildCommand> - <name>org.eclipse.jdt.core.javabuilder</name> - <arguments> - </arguments> - </buildCommand> - <buildCommand> <name>org.maven.ide.eclipse.maven2Builder</name> <arguments> </arguments> </buildCommand> </buildSpec> <natures> - <nature>org.eclipse.jdt.core.javanature</nature> <nature>org.maven.ide.eclipse.maven2Nature</nature> </natures> </projectDescription> Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,7 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<classpath> - <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> - <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> - <classpathentry kind="output" path="target/classes"/> -</classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.project =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.project 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/.project 2009-05-04 09:33:28 UTC (rev 4706) @@ -6,18 +6,12 @@ </projects> <buildSpec> <buildCommand> - <name>org.eclipse.jdt.core.javabuilder</name> - <arguments> - </arguments> - </buildCommand> - <buildCommand> <name>org.maven.ide.eclipse.maven2Builder</name> <arguments> </arguments> </buildCommand> </buildSpec> <natures> - <nature>org.eclipse.jdt.core.javanature</nature> <nature>org.maven.ide.eclipse.maven2Nature</nature> </natures> </projectDescription> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/pom.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/pom.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/pom.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -154,11 +154,6 @@ <artifactId>ant</artifactId> </dependency> <dependency> - <groupId>org.eclipse.birt</groupId> - <artifactId>report-engine</artifactId> - <type>zip</type> - </dependency> - <dependency> <groupId>hsqldb</groupId> <artifactId>hsqldb</artifactId> </dependency> @@ -166,8 +161,6 @@ <groupId>izpack</groupId> <artifactId>standalone-compiler</artifactId> </dependency> - - <!-- Database Drivers --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> @@ -176,6 +169,8 @@ <groupId>postgresql</groupId> <artifactId>postgresql</artifactId> </dependency> + + <!-- Database Drivers --> </dependencies> <!-- Plugins --> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/ant-actions-spec.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/ant-actions-spec.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/ant-actions-spec.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,11 +1,11 @@ <antactions> - <pack name="Download JBoss-5.0.0"> + <pack name="Download JBoss-5.0.1"> <antcall order="afterpack" buildfile="$INSTALL_PATH/Uninstaller/download-helper.xml"> <property name="install.path" value="$INSTALL_PATH"/> <target name="download-jboss"/> </antcall> </pack> - <pack name="Download Eclipse-3.4.0"> + <pack name="Download Eclipse-3.4.2"> <antcall order="afterpack" buildfile="$INSTALL_PATH/Uninstaller/download-helper.xml"> <property name="install.path" value="$INSTALL_PATH"/> <target name="download-eclipse"/> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/auto-install-template.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/auto-install-template.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/auto-install-template.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -9,8 +9,8 @@ <pack name="JSF-Console" index="2" selected="true"/> <pack name="GWT-Console" index="3" selected="true"/> <pack name="Optional Components" index="4" selected="false"/> - <pack name="Download JBoss-5.0.0" index="5" selected="false"/> - <pack name="Download Eclipse-3.4.0" index="6" selected="false"/> + <pack name="Download JBoss-5.0.1" index="5" selected="false"/> + <pack name="Download Eclipse-3.4.2" index="6" selected="false"/> </com.izforge.izpack.panels.TreePacksPanel> <com.izforge.izpack.panels.UserInputPanel> <userInput> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/download-helper.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/download-helper.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/download-helper.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -13,11 +13,11 @@ <project> <target name="download-jboss"> - <get src="http://downloads.sourceforge.net/jboss/jboss-5.0.0.GA.zip?modti... dest="${install.path}/Uninstaller/jboss-5.0.0.GA.zip" usetimestamp="true"/> - <unzip src="${install.path}/Uninstaller/jboss-5.0.0.GA.zip" dest="${install.path}"/> + <get src="http://downloads.sourceforge.net/jboss/jboss-5.0.1.GA.zip" dest="${install.path}/Uninstaller/jboss-5.0.1.GA.zip" usetimestamp="true"/> + <unzip src="${install.path}/Uninstaller/jboss-5.0.1.GA.zip" dest="${install.path}"/> </target> <target name="download-eclipse"> - <get src="http://download.eclipse.org/technology/epp/downloads/release/ga... + <get src="http://mirrors.ibiblio.org/pub/mirrors/eclipse/technology/epp/d... dest="${install.path}/Uninstaller/eclipse-java-ganymede-linux-gtk.tar.gz" usetimestamp="true"/> <untar src="${install.path}/Uninstaller/eclipse-java-ganymede-linux-gtk.tar.gz" dest="${install.path}" compression="gzip"/> </target> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/install-definition.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/install-definition.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/install-definition.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -38,32 +38,32 @@ <!-- Variables --> <variables> - <variable name="jboss422.home" value=&quot;(a){jboss422.home}&quot; /> + <variable name="jboss405.home" value=&quot;(a){jboss405.home}&quot; /> <variable name="jboss423.home" value=&quot;(a){jboss423.home}&quot; /> - <variable name="jboss500.home" value=&quot;(a){jboss500.home}&quot; /> + <variable name="jboss501.home" value=&quot;(a){jboss501.home}&quot; /> </variables> <!-- Dynamic Variables --> <dynamicvariables> - <variable name="jboss.home" value="${jboss422.home}" condition="isJBoss422" /> + <variable name="jboss.home" value="${jboss405.home}" condition="isJBoss405" /> <variable name="jboss.home" value="${jboss423.home}" condition="isJBoss423" /> - <variable name="jboss.home" value="${jboss500.home}" condition="isJBoss500" /> + <variable name="jboss.home" value="${jboss501.home}" condition="isJBoss501" /> </dynamicvariables> <!-- Conditions --> <conditions> <!-- Target Server Conditions --> - <condition type="variable" id="isJBoss422"> + <condition type="variable" id="isJBoss405"> <name>jbossSelection</name> - <value>jboss422</value> + <value>jboss405</value> </condition> <condition type="variable" id="isJBoss423"> <name>jbossSelection</name> <value>jboss423</value> </condition> - <condition type="variable" id="isJBoss500"> + <condition type="variable" id="isJBoss501"> <name>jbossSelection</name> - <value>jboss500</value> + <value>jboss501</value> </condition> <!-- Target Database Conditions --> @@ -322,16 +322,16 @@ <description>Optional jBPM3 Components</description> </pack> - <!-- JBoss-5.0.0 --> - <pack name="Download JBoss-5.0.0" required="no" parent="Optional Components" preselected="no"> - <description>Download and Install JBoss-5.0.0</description> + <!-- JBoss-5.0.1 --> + <pack name="Download JBoss-5.0.1" required="no" parent="Optional Components" preselected="no"> + <description>Download and Install JBoss-5.0.1</description> <!-- http://jira.codehaus.org/browse/IZPACK-158 --> <file src=&quot;(a){resources.dir}/installer/download-helper.xml&quot; targetdir="$INSTALL_PATH/Uninstaller"/> </pack> - <!-- Eclipse-3.4.0 --> - <pack name="Download Eclipse-3.4.0" required="no" parent="Optional Components" preselected="no"> - <description>Download and Install Eclipse-3.4.0</description> + <!-- Eclipse-3.4.2 --> + <pack name="Download Eclipse-3.4.2" required="no" parent="Optional Components" preselected="no"> + <description>Download and Install Eclipse-3.4.2</description> <!-- http://jira.codehaus.org/browse/IZPACK-158 --> <file src=&quot;(a){resources.dir}/installer/download-helper.xml&quot; targetdir="$INSTALL_PATH/Uninstaller"/> </pack> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/user-input-spec.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/user-input-spec.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/distribution/src/main/resources/installer/user-input-spec.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,9 +4,9 @@ <field type="radio" variable="jbossSelection"> <description align="left" txt="Please choose your target server" /> <spec> - <choice txt="JBoss-5.0.0" value="jboss500" set="true"/> + <choice txt="JBoss-5.0.1" value="jboss501" set="true"/> <choice txt="JBoss-4.2.3" value="jboss423"/> - <choice txt="JBoss-4.2.2" value="jboss422"/> + <choice txt="JBoss-4.0.5" value="jboss405"/> </spec> </field> <field type="text" variable="jbossTargetServer"> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,7 +4,7 @@ <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/> <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> <classpathentry kind="output" path="target/classes"/> </classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/pom.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/pom.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/pom.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -43,16 +43,11 @@ <!-- Provided Dependencies --> <dependency> - <groupId>javax.ejb</groupId> - <artifactId>ejb-api</artifactId> + <groupId>jboss</groupId> + <artifactId>jboss-j2ee</artifactId> <scope>provided</scope> </dependency> <dependency> - <groupId>javax.jms</groupId> - <artifactId>jms</artifactId> - <scope>provided</scope> - </dependency> - <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <scope>provided</scope> @@ -62,8 +57,6 @@ <artifactId>hibernate</artifactId> <scope>provided</scope> </dependency> - - <!-- Test Dependencies --> <dependency> <groupId>org.apache.cactus</groupId> <artifactId>cactus.core.framework.wrapper.javaEE.14</artifactId> @@ -91,16 +84,8 @@ <artifactId>jbossall-client</artifactId> <scope>test</scope> </dependency> - <dependency> - <groupId>org.jboss.bpm</groupId> - <artifactId>bpm-spec-api</artifactId> - <scope>test</scope> - </dependency> - <dependency> - <groupId>org.slf4j</groupId> - <artifactId>slf4j-log4j12</artifactId> - <scope>test</scope> - </dependency> + + <!-- Test Dependencies --> </dependencies> <!-- Plugins --> @@ -326,12 +311,6 @@ <plugins> <plugin> <artifactId>maven-surefire-plugin</artifactId> - <configuration> - <excludes> - <!-- [JBPM-1818] Use Sybase instance that supports XA Transaction --> - <exclude>org/jbpm/enterprise/deployment/DeploymentPARTest.java</exclude> - </excludes> - </configuration> </plugin> </plugins> </build> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -23,7 +23,6 @@ import java.io.PrintWriter; import java.io.StringWriter; -import java.util.Arrays; import java.util.List; import javax.jms.Destination; @@ -35,6 +34,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.command.Command; import org.jbpm.db.JobSession; @@ -42,9 +42,11 @@ import org.jbpm.msg.jms.JmsMessageService; import org.jbpm.msg.jms.JmsMessageServiceFactory; import org.jbpm.svc.Services; +import org.jbpm.util.ArrayUtil; /** * Individual job processing command. + * * @author Alejandro Guizar */ public class ExecuteJobCommand implements Command { @@ -85,9 +87,9 @@ exclusiveJob.setLockOwner(lockOwner); exclusiveJobIds[i] = exclusiveJob.getId(); } - log.debug("locking jobs " + Arrays.toString(exclusiveJobIds)); + log.debug("locking jobs " + ArrayUtil.toString(exclusiveJobIds)); // execute exclusive jobs in separate transaction - postJobsExecution(jbpmContext, exclusiveJobIds); + postJobsExecution(jbpmContext, exclusiveJobIds); } else { // lock job to prevent others from deleting it Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobsCommand.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobsCommand.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/main/java/org/jbpm/ejb/impl/ExecuteJobsCommand.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,18 +21,20 @@ */ package org.jbpm.ejb.impl; -import java.util.Arrays; import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; import org.jbpm.command.Command; import org.jbpm.job.Job; +import org.jbpm.util.ArrayUtil; /** * Batch job processing command. + * * @author Alejandro Guizar */ public class ExecuteJobsCommand implements Command { @@ -47,7 +49,7 @@ } public Object execute(JbpmContext jbpmContext) throws Exception { - log.debug("executing jobs " + Arrays.toString(jobIds)); + log.debug("executing jobs " + ArrayUtil.toString(jobIds)); List jobs = jbpmContext.getJobSession().loadJobs(jobIds); for (Iterator i = jobs.iterator(); i.hasNext();) { Job job = (Job) i.next(); Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ArchiveDeployer.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ArchiveDeployer.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ArchiveDeployer.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,43 @@ +/* + * 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.enterprise; + +import java.net.URL; + +/** + * An archive deployer + * + * @author Thomas.Diesler(a)jboss.org + * @since 16-May-2006 + */ +public interface ArchiveDeployer { + + /** + * Deploy the given archive + */ + void deploy(URL archive) throws Exception; + + /** + * Undeploy the given archive + */ + void undeploy(URL archive) throws Exception; +} Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestHelper.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestHelper.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestHelper.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,169 @@ +/* + * 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.enterprise; + +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.util.Hashtable; + +import javax.management.JMException; +import javax.management.MBeanServerConnection; +import javax.management.ObjectName; +import javax.naming.InitialContext; +import javax.naming.NamingException; + +import org.jbpm.JbpmException; + +/** + * An integration test helper that deals with test deployment/undeployment, etc. + * + * @author Thomas.Diesler(a)jboss.org + * @since 14-Oct-2004 + */ +public class IntegrationTestHelper { + + private String testResourcesDir; + private String testArchiveDir; + private String integrationTarget; + + private static final String SYSPROP_TEST_RESOURCES_DIRECTORY = "test.resources.directory"; + private static final String SYSPROP_TEST_ARCHIVE_DIRECTORY = "test.archive.directory"; + + private static MBeanServerConnection server; + + public String getTestResourcesDir() { + if (testResourcesDir == null) { + testResourcesDir = System.getProperty(SYSPROP_TEST_RESOURCES_DIRECTORY, "target/test-classes"); + } + return testResourcesDir; + } + + /** Try to discover the File for the test resource */ + public File getResourceFile(String resource) { + File file = new File(resource); + if (file.exists()) return file; + + file = new File(getTestResourcesDir() + "/" + resource); + if (file.exists()) return file; + + throw new IllegalArgumentException("Cannot obtain '" + + getTestResourcesDir() + + "/" + + resource + + "'"); + } + + public String getTestArchiveDir() { + if (testArchiveDir == null) { + testArchiveDir = System.getProperty(SYSPROP_TEST_ARCHIVE_DIRECTORY, "target/test-libs"); + } + return testArchiveDir; + } + + /** Try to discover the File for the deployment archive */ + public File getTestArchiveFile(String archive) { + File file = new File(archive); + if (file.exists()) return file; + + file = new File(getTestArchiveDir() + "/" + archive); + if (file.exists()) return file; + + String notSet = getTestArchiveDir() == null ? " System property '" + + SYSPROP_TEST_ARCHIVE_DIRECTORY + + "' not set." : ""; + throw new IllegalArgumentException("Cannot obtain '" + + getTestArchiveDir() + + "/" + + archive + + "'." + + notSet); + } + + public void deploy(String archive) throws Exception { + URL url = getTestArchiveFile(archive).toURI().toURL(); + deploy(url); + } + + public void deploy(URL archive) throws Exception { + getDeployer().deploy(archive); + } + + public void undeploy(String archive) throws Exception { + URL url = getTestArchiveFile(archive).toURI().toURL(); + undeploy(url); + } + + public void undeploy(URL archive) throws Exception { + getDeployer().undeploy(archive); + } + + public String getIntegrationTarget() { + if (integrationTarget == null) { + String jbossVersion; + try { + ObjectName oname = ObjectNameFactory.create("jboss.system:type=Server"); + jbossVersion = (String) getServer().getAttribute(oname, "Version"); + } + catch (JMException e) { + throw new JbpmException("cannot obtain jboss version", e); + } + catch (IOException e) { + throw new JbpmException("cannot obtain jboss version", e); + } + + if (jbossVersion.startsWith("5.0.1")) + integrationTarget = "jboss501"; + if (jbossVersion.startsWith("5.0.0")) + integrationTarget = "jboss500"; + else if (jbossVersion.startsWith("4.2.3")) + integrationTarget = "jboss423"; + else if (jbossVersion.startsWith("4.2.2")) + integrationTarget = "jboss422"; + else if (jbossVersion.startsWith("4.0.5")) + integrationTarget = "jboss405"; + else + throw new JbpmException("unsupported jboss version: " + jbossVersion); + } + return integrationTarget; + } + + public MBeanServerConnection getServer() { + if (server == null) { + Hashtable jndiEnv = null; + try { + InitialContext iniCtx = new InitialContext(); + jndiEnv = iniCtx.getEnvironment(); + server = (MBeanServerConnection) iniCtx.lookup("jmx/invoker/RMIAdaptor"); + } + catch (NamingException ex) { + throw new RuntimeException("Cannot obtain MBeanServerConnection using jndi props: " + + jndiEnv, ex); + } + } + return server; + } + + private ArchiveDeployer getDeployer() { + return new JBossArchiveDeployer(getServer()); + } +} Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestSetup.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestSetup.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/IntegrationTestSetup.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,120 @@ +/* + * 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.enterprise; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.List; +import java.util.StringTokenizer; + +import javax.management.MBeanServerConnection; + +import junit.extensions.TestSetup; +import junit.framework.TestSuite; + +/** + * A test setup that deploys/undeploys archives + * + * @author Thomas.Diesler(a)jboss.org + * @since 14-Oct-2004 + */ +public class IntegrationTestSetup extends TestSetup { + + private IntegrationTestHelper delegate = new IntegrationTestHelper(); + private String[] archives = new String[0]; + private ClassLoader originalClassLoader; + + public IntegrationTestSetup(Class testClass, String archiveList) { + super(new TestSuite(testClass)); + getArchiveArray(archiveList); + } + + public File getArchiveFile(String archive) { + return delegate.getTestArchiveFile(archive); + } + + public URL getArchiveURL(String archive) throws MalformedURLException { + return delegate.getTestArchiveFile(archive).toURI().toURL(); + } + + public MBeanServerConnection getServer() { + return delegate.getServer(); + } + + private void getArchiveArray(String archiveList) { + if (archiveList != null) { + StringTokenizer st = new StringTokenizer(archiveList, ", "); + archives = new String[st.countTokens()]; + + for (int i = 0; i < archives.length; i++) + archives[i] = st.nextToken(); + } + } + + protected void setUp() throws Exception { + super.setUp(); + + List clientJars = new ArrayList(); + for (int i = 0; i < archives.length; i++) { + String archive = archives[i]; + try { + delegate.deploy(archive); + } + catch (Exception ex) { + ex.printStackTrace(); + delegate.undeploy(archive); + } + + if (archive.endsWith("-client.jar")) { + URL archiveURL = getArchiveURL(archive); + clientJars.add(archiveURL); + } + } + + ClassLoader parent = Thread.currentThread().getContextClassLoader(); + originalClassLoader = parent; + + // add client jars to the class loader + if (!clientJars.isEmpty()) { + URL[] urls = new URL[clientJars.size()]; + clientJars.toArray(urls); + URLClassLoader cl = new URLClassLoader(urls, parent); + Thread.currentThread().setContextClassLoader(cl); + } + } + + protected void tearDown() throws Exception { + try { + for (int i = 0; i < archives.length; i++) { + String archive = archives[archives.length - i - 1]; + delegate.undeploy(archive); + } + } + finally { + Thread.currentThread().setContextClassLoader(originalClassLoader); + } + super.tearDown(); + } +} Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/JBossArchiveDeployer.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/JBossArchiveDeployer.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/JBossArchiveDeployer.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,57 @@ +/* + * 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.enterprise; + +import java.net.URL; + +import javax.management.MBeanServerConnection; +import javax.management.ObjectName; + +/** + * An archive deployer that deals with test deployment/undeployment, etc. + * + * @author Thomas.Diesler(a)jboss.org + * @since 14-Oct-2004 + */ +public class JBossArchiveDeployer implements ArchiveDeployer { + + private MBeanServerConnection server; + + private static final String MAIN_DEPLOYER = "jboss.system:service=MainDeployer"; + + public JBossArchiveDeployer(MBeanServerConnection server) { + this.server = server; + } + + public void deploy(URL url) throws Exception { + invokeMainDeployer("deploy", url); + } + + public void undeploy(URL url) throws Exception { + invokeMainDeployer("undeploy", url); + } + + private void invokeMainDeployer(String methodName, URL url) throws Exception { + server.invoke(new ObjectName(MAIN_DEPLOYER), methodName, new Object[] { url }, + new String[] { "java.net.URL" }); + } +} Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ObjectNameFactory.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ObjectNameFactory.java (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ObjectNameFactory.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,63 @@ +/* + * 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.enterprise; + +import java.util.Hashtable; + +import javax.management.MalformedObjectNameException; +import javax.management.ObjectName; + +/** + * A simple factory for creating safe object names. + * + * @author Thomas.Diesler(a)jboss.org + * @since 08-May-2006 + */ +public class ObjectNameFactory { + + public static ObjectName create(String name) { + try { + return new ObjectName(name); + } + catch (MalformedObjectNameException e) { + throw new Error("Invalid ObjectName: " + name + "; " + e); + } + } + + public static ObjectName create(String domain, String key, String value) { + try { + return new ObjectName(domain, key, value); + } + catch (MalformedObjectNameException e) { + throw new Error("Invalid ObjectName: " + domain + "," + key + "," + value + "; " + e); + } + } + + public static ObjectName create(String domain, Hashtable table) { + try { + return new ObjectName(domain, table); + } + catch (MalformedObjectNameException e) { + throw new Error("Invalid ObjectName: " + domain + "," + table + "; " + e); + } + } +} Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/AppServerConfigurationsTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/AppServerConfigurationsTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/AppServerConfigurationsTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -24,49 +24,51 @@ import junit.framework.Test; import org.apache.cactus.ServletTestCase; + import org.jbpm.JbpmConfiguration; -import org.jboss.bpm.api.test.IntegrationTestSetup; +import org.jbpm.enterprise.IntegrationTestSetup; import org.jbpm.msg.jms.JmsMessageServiceFactory; import org.jbpm.persistence.jta.JtaDbPersistenceServiceFactory; import org.jbpm.scheduler.ejbtimer.EntitySchedulerServiceFactory; import org.jbpm.svc.Services; -public class AppServerConfigurationsTest extends ServletTestCase -{ +public class AppServerConfigurationsTest extends ServletTestCase { + JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(); - public static Test suite() throws Exception - { - return new IntegrationTestSetup(AppServerConfigurationsTest.class, "enterprise-test.war"); + public static Test suite() throws Exception { + return new IntegrationTestSetup(AppServerConfigurationsTest.class, "enterprise-test.war"); } - - public void testUnavailabilityOfTheJobExecutor() - { + + public void testUnavailabilityOfTheJobExecutor() { assertNull(jbpmConfiguration.getJobExecutor()); } - public void testJtaDbPersistenceFactoryConfiguration() - { + public void testJtaDbPersistenceFactoryConfiguration() { String expService = JtaDbPersistenceServiceFactory.class.getName(); - String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE).getClass().getName(); + String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE) + .getClass() + .getName(); assertEquals(expService, wasService); - - JtaDbPersistenceServiceFactory persistenceServiceFactory = (JtaDbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + + JtaDbPersistenceServiceFactory persistenceServiceFactory = (JtaDbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); assertFalse(persistenceServiceFactory.isTransactionEnabled()); assertTrue(persistenceServiceFactory.isCurrentSessionEnabled()); } - public void testJmsMessageServiceFactoryConfiguration() - { + public void testJmsMessageServiceFactoryConfiguration() { String expService = JmsMessageServiceFactory.class.getName(); - String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_MESSAGE).getClass().getName(); + String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_MESSAGE) + .getClass() + .getName(); assertEquals(expService, wasService); } - public void testEjbSchedulerServiceFactoryConfiguration() - { + public void testEjbSchedulerServiceFactoryConfiguration() { String expService = EntitySchedulerServiceFactory.class.getName(); - String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_SCHEDULER).getClass().getName(); + String wasService = jbpmConfiguration.getServiceFactory(Services.SERVICENAME_SCHEDULER) + .getClass() + .getName(); assertEquals(expService, wasService); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/ContainerProvidedJarsTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/ContainerProvidedJarsTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/config/ContainerProvidedJarsTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -21,20 +21,19 @@ */ package org.jbpm.enterprise.config; -// $Id$ - import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.util.ArrayList; +import java.util.Iterator; import java.util.List; import javax.management.ObjectName; import junit.framework.TestCase; -import org.jboss.bpm.api.model.ObjectNameFactory; -import org.jboss.bpm.api.test.IntegrationTestHelper; +import org.jbpm.enterprise.IntegrationTestHelper; +import org.jbpm.enterprise.ObjectNameFactory; /** * Test that there are jars deployed which should in fact be provided by the container @@ -42,58 +41,38 @@ * @author thomas.diesler(a)jboss.com * @since 23-Sep-2008 */ -public class ContainerProvidedJarsTest extends TestCase -{ +public class ContainerProvidedJarsTest extends TestCase { + IntegrationTestHelper delegate = new IntegrationTestHelper(); - - public void testDependencies() throws Exception - { - String targetContainer = null; - if (delegate.isTargetJBoss422()) - { - targetContainer = "jboss422"; - } - else if (delegate.isTargetJBoss423()) - { - targetContainer = "jboss423"; - } - else if (delegate.isTargetJBoss500()) - { - targetContainer = "jboss500"; - } - assertNotNull("System property 'target.container' not null", targetContainer); - assertTrue("Supported target.container: " + targetContainer, "jboss422,jboss423,jboss500".indexOf(targetContainer) >= 0); + public void testDependencies() throws Exception { + String targetContainer = delegate.getIntegrationTarget(); File jbossJars = delegate.getResourceFile(targetContainer + "-dependencies.txt"); assertTrue("JBoss jar fixture exists: " + jbossJars, jbossJars.exists()); // Read the JBoss ServerHomeDir ObjectName oname = ObjectNameFactory.create("jboss.system:type=ServerConfig"); - File serverHomeDir = (File)delegate.getServer().getAttribute(oname, "ServerHomeDir"); - if (serverHomeDir == null) - throw new IllegalStateException("Cannot obtain jboss home dir"); + File serverHomeDir = (File) delegate.getServer().getAttribute(oname, "ServerHomeDir"); + if (serverHomeDir == null) throw new IllegalStateException("Cannot obtain jboss home dir"); File jbpmDir = new File(serverHomeDir + "/deploy/jbpm"); assertTrue("jBPM dir exists: " + jbpmDir, jbpmDir.exists()); - - List<String> deployedJars = getDeployedJars(jbpmDir); + List deployedJars = getDeployedJars(jbpmDir); + // Iterate over the known server provided jars - List<String> matchingJars = new ArrayList<String>(); + List matchingJars = new ArrayList(); BufferedReader br = new BufferedReader(new FileReader(jbossJars)); String jbossJar = br.readLine(); - while (jbossJar != null) - { - if (jbossJar.length() == 0 || jbossJar.startsWith("#")) - { + while (jbossJar != null) { + if (jbossJar.length() == 0 || jbossJar.startsWith("#")) { jbossJar = br.readLine(); continue; } - for (String deployedJar : deployedJars) - { - if (deployedJar.startsWith(jbossJar)) - matchingJars.add(deployedJar); + for (Iterator i = deployedJars.iterator(); i.hasNext();) { + String deployedJar = (String) i.next(); + if (deployedJar.startsWith(jbossJar)) matchingJars.add(deployedJar); } jbossJar = br.readLine(); } @@ -101,20 +80,19 @@ assertEquals("Invalid deployed jars: " + matchingJars, 0, matchingJars.size()); } - private List<String> getDeployedJars(File subdir) - { - List<String> deployedJars = new ArrayList<String>(); - for (File file : subdir.listFiles()) - { - if (file.isDirectory()) - { + private List getDeployedJars(File subdir) { + List deployedJars = new ArrayList(); + File[] files = subdir.listFiles(); + for (int i = 0; i < files.length; i++) { + File file = files[i]; + if (file.isDirectory()) { deployedJars.addAll(getDeployedJars(file)); continue; } - + String fileName = file.getName(); - if (fileName.endsWith(".jar") && !fileName.startsWith("jbpm") && !fileName.startsWith("jboss-bpm")) - { + if (fileName.endsWith(".jar") + && !fileName.startsWith("jbpm")) { deployedJars.add(fileName); } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ejbtimer/EjbSchedulerTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ejbtimer/EjbSchedulerTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/ejbtimer/EjbSchedulerTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -32,13 +32,14 @@ import org.apache.cactus.ServletTestCase; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmContext; -import org.jboss.bpm.api.test.IntegrationTestSetup; import org.jbpm.command.Command; import org.jbpm.command.DeployProcessCommand; import org.jbpm.command.StartProcessInstanceCommand; import org.jbpm.ejb.LocalCommandService; import org.jbpm.ejb.LocalCommandServiceHome; +import org.jbpm.enterprise.IntegrationTestSetup; import org.jbpm.graph.def.Event; import org.jbpm.graph.def.EventCallback; import org.jbpm.graph.def.ProcessDefinition; @@ -272,7 +273,7 @@ private ProcessInstance launchProcess(String processName) throws RemoteException { StartProcessInstanceCommand command = new StartProcessInstanceCommand(); - command.setProcessName(processName); + command.setProcessDefinitionName(processName); command.setVariables(Collections.singletonMap("eventCallback", new EventCallback())); return (ProcessInstance) commandService.execute(command); } @@ -306,7 +307,7 @@ private static final long serialVersionUID = 1L; public Object execute(JbpmContext jbpmContext) throws Exception { - return jbpmContext.loadProcessInstance(processId).hasEnded(); + return Boolean.valueOf(jbpmContext.loadProcessInstance(processId).hasEnded()); } }); return isFinished.booleanValue(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jbpm1903/JBPM1903Test.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jbpm1903/JBPM1903Test.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jbpm1903/JBPM1903Test.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -37,13 +37,14 @@ import org.apache.cactus.ServletTestCase; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.jboss.bpm.api.test.IntegrationTestSetup; + import org.jbpm.JbpmContext; import org.jbpm.command.Command; import org.jbpm.command.DeployProcessCommand; import org.jbpm.command.StartProcessInstanceCommand; import org.jbpm.ejb.LocalCommandService; import org.jbpm.ejb.LocalCommandServiceHome; +import org.jbpm.enterprise.IntegrationTestSetup; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.util.IoUtil; @@ -61,7 +62,6 @@ return new IntegrationTestSetup(JBPM1903Test.class, "enterprise-test.war"); } - @Override protected void setUp() throws Exception { if (commandServiceHome == null) { Context initialContext = new InitialContext(); @@ -76,7 +76,6 @@ log.info("### " + getName() + " started ###"); } - @Override protected void tearDown() throws Exception { log.info("### " + getName() + " done ###"); commandService = null; @@ -118,6 +117,7 @@ private Object getVariable(final long processInstanceId, final String variableName) { return commandService.execute(new Command() { + private static final long serialVersionUID = 1L; public Object execute(JbpmContext jbpmContext) throws Exception { Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jms/JmsMessageTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jms/JmsMessageTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jms/JmsMessageTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -32,13 +32,14 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hibernate.cfg.Environment; -import org.jboss.bpm.api.test.IntegrationTestSetup; + import org.jbpm.JbpmContext; import org.jbpm.command.Command; import org.jbpm.command.DeployProcessCommand; import org.jbpm.command.StartProcessInstanceCommand; import org.jbpm.ejb.LocalCommandService; import org.jbpm.ejb.LocalCommandServiceHome; +import org.jbpm.enterprise.IntegrationTestSetup; import org.jbpm.graph.def.Event; import org.jbpm.graph.def.EventCallback; import org.jbpm.graph.def.ProcessDefinition; @@ -52,10 +53,8 @@ * * @author Alejandro Guizar */ -public class JmsMessageTest extends ServletTestCase -{ - private static Log log = LogFactory.getLog(JmsMessageTest.class); - +public class JmsMessageTest extends ServletTestCase { + private LocalCommandService commandService; private static LocalCommandServiceHome commandServiceHome; @@ -63,22 +62,19 @@ static final int processExecutionCount = 5; static final int maxWaitTime = 10 * 1000; - public static Test suite() throws Exception - { + private static final Log log = LogFactory.getLog(JmsMessageTest.class); + + public static Test suite() throws Exception { return new IntegrationTestSetup(JmsMessageTest.class, "enterprise-test.war"); } - protected void setUp() throws Exception - { - if (commandServiceHome == null) - { + protected void setUp() throws Exception { + if (commandServiceHome == null) { Context initialContext = new InitialContext(); - try - { - commandServiceHome = (LocalCommandServiceHome)initialContext.lookup("java:comp/env/ejb/CommandServiceBean"); + try { + commandServiceHome = (LocalCommandServiceHome) initialContext.lookup("java:comp/env/ejb/CommandServiceBean"); } - finally - { + finally { initialContext.close(); } } @@ -86,15 +82,13 @@ log.info("### " + getName() + " started ###"); } - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { log.info("### " + getName() + " done ###"); commandService = null; EventCallback.clear(); } - public void testAsyncNode() - { + public void testAsyncNode() { deployProcess("<process-definition name='node'>" + " <event type='process-end'>" + " <action expression='#{eventCallback.processEnd}'/>" @@ -107,14 +101,13 @@ + " </node>" + " <end-state name='end' />" + "</process-definition>"); - + long processId = launchProcess("node").getId(); EventCallback.waitForEvent(Event.EVENTTYPE_PROCESS_END); assertTrue("Process has ended", hasProcessEnded(processId)); } - public void testAsyncAction() - { + public void testAsyncAction() { deployProcess("<process-definition name='action'>" + " <start-state name='start'>" + " <transition to='a' />" @@ -132,7 +125,7 @@ + " </node>" + " <end-state name='end' />" + "</process-definition>"); - + long processId = launchProcess("action").getId(); EventCallback.waitForEvent(Event.EVENTTYPE_NODE_ENTER); EventCallback.waitForEvent(Event.EVENTTYPE_NODE_LEAVE); @@ -140,8 +133,7 @@ assertTrue("Process has ended", hasProcessEnded(processId)); } - public void testAsyncSequence() - { + public void testAsyncSequence() { deployProcess("<process-definition name='sequence'>" + " <event type='process-end'>" + " <action expression='#{eventCallback.processEnd}'/>" @@ -166,17 +158,15 @@ + " </node>" + " <end-state name='end' />" + "</process-definition>"); - + long processId = launchProcess("sequence").getId(); EventCallback.waitForEvent(Event.EVENTTYPE_PROCESS_END); assertTrue("Process has ended", hasProcessEnded(processId)); } - public void testAsyncFork() throws Exception - { + public void testAsyncFork() throws Exception { // [JBPM-1811] JmsMessageTest fails intermittently on HSQLDB - if (getHibernateDialect().indexOf("HSQL") != -1) - { + if (getHibernateDialect().indexOf("HSQL") != -1) { return; } @@ -214,28 +204,25 @@ + " </join>" + " <end-state name='end' />" + "</process-definition>"); - + long processId = launchProcess("fork").getId(); EventCallback.waitForEvent(Event.EVENTTYPE_PROCESS_END); assertTrue("Process has ended", hasProcessEnded(processId)); } - private String getHibernateDialect() - { - return (String)commandService.execute(new Command() - { + private String getHibernateDialect() { + return (String) commandService.execute(new Command() { + private static final long serialVersionUID = 1L; - public Object execute(JbpmContext jbpmContext) throws Exception - { - DbPersistenceServiceFactory factory = (DbPersistenceServiceFactory)jbpmContext.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + public Object execute(JbpmContext jbpmContext) throws Exception { + DbPersistenceServiceFactory factory = (DbPersistenceServiceFactory) jbpmContext.getServiceFactory(Services.SERVICENAME_PERSISTENCE); return factory.getConfiguration().getProperty(Environment.DIALECT); } }); } - public void testAsyncExecutions() - { + public void testAsyncExecutions() { deployProcess("<process-definition name='execution'>" + " <event type='process-end'>" + " <action expression='#{eventCallback.processEnd}' />" @@ -266,10 +253,9 @@ + " </node>" + " <end-state name='end' />" + "</process-definition>"); - + long[] processIds = new long[processExecutionCount]; - for (int i = 0; i < processExecutionCount; i++) - { + for (int i = 0; i < processExecutionCount; i++) { processIds[i] = launchProcess("execution").getId(); EventCallback.waitForEvent(Event.EVENTTYPE_NODE_ENTER); } @@ -277,36 +263,30 @@ EventCallback.waitForEvent(processExecutionCount, Event.EVENTTYPE_NODE_LEAVE); EventCallback.waitForEvent(processExecutionCount, Event.EVENTTYPE_PROCESS_END); - for (int i = 0; i < processExecutionCount; i++) - { + for (int i = 0; i < processExecutionCount; i++) { long processId = processIds[i]; - assertTrue("expected process " + processId + " to have ended", - hasProcessEnded(processId)); + assertTrue("expected process " + processId + " to have ended", hasProcessEnded(processId)); } } - private ProcessDefinition deployProcess(String xml) - { + private ProcessDefinition deployProcess(String xml) { return (ProcessDefinition) commandService.execute(new DeployProcessCommand(xml)); } - private ProcessInstance launchProcess(String processName) - { + private ProcessInstance launchProcess(String processName) { StartProcessInstanceCommand command = new StartProcessInstanceCommand(); command.setProcessDefinitionName(processName); command.setVariables(Collections.singletonMap("eventCallback", new EventCallback())); - return (ProcessInstance)commandService.execute(command); + return (ProcessInstance) commandService.execute(command); } - private boolean hasProcessEnded(final long processId) - { - Boolean isFinished = (Boolean)commandService.execute(new Command() - { + private boolean hasProcessEnded(final long processId) { + Boolean isFinished = (Boolean) commandService.execute(new Command() { + private static final long serialVersionUID = 1L; - public Object execute(JbpmContext jbpmContext) throws Exception - { - return jbpmContext.loadProcessInstance(processId).hasEnded(); + public Object execute(JbpmContext jbpmContext) throws Exception { + return Boolean.valueOf(jbpmContext.loadProcessInstance(processId).hasEnded()); } }); return isFinished.booleanValue(); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jta/JtaDbPersistenceTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jta/JtaDbPersistenceTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/java/org/jbpm/enterprise/jta/JtaDbPersistenceTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,15 +29,15 @@ import junit.framework.Test; import org.apache.cactus.ServletTestCase; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; -import org.jboss.bpm.api.test.IntegrationTestSetup; +import org.jbpm.enterprise.IntegrationTestSetup; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.persistence.jta.JtaDbPersistenceService; -public class JtaDbPersistenceTest extends ServletTestCase -{ +public class JtaDbPersistenceTest extends ServletTestCase { private JbpmConfiguration jbpmConfiguration; private UserTransaction tx; @@ -45,38 +45,32 @@ private static long definitionId; - public static Test suite() throws Exception - { + public static Test suite() throws Exception { return new IntegrationTestSetup(JtaDbPersistenceTest.class, "enterprise-test.war"); } - protected void setUp() throws Exception - { + protected void setUp() throws Exception { jbpmConfiguration = JbpmConfiguration.getInstance(); } - public void testUserTx() throws Exception - { + public void testUserTx() throws Exception { tx = getUserTransaction(); testServiceTx(); } - public void testUserTxRollback() throws Exception - { + public void testUserTxRollback() throws Exception { tx = getUserTransaction(); testServiceTxRollback(); } - public void testServiceTx() throws Exception - { + public void testServiceTx() throws Exception { long definitionId = deployProcess(); long instanceId = launchProcess(definitionId); signal(instanceId); assertTrue(hasEnded(instanceId)); } - public void testServiceTxRollback() throws Exception - { + public void testServiceTxRollback() throws Exception { rollback = true; long definitionId = deployProcess(); long instanceId = launchProcess(definitionId); @@ -84,177 +78,134 @@ assertFalse(hasEnded(instanceId)); } - private long deployProcess() throws Exception - { - if (definitionId == 0) - { - try - { - if (tx != null) - tx.begin(); + private long deployProcess() throws Exception { + if (definitionId == 0) { + try { + if (tx != null) tx.begin(); JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { assertEquals(tx == null, isTxCreatedByService(jbpmContext)); - ProcessDefinition definition = ProcessDefinition.parseXmlString( - "<process-definition name='tx'>" + - " <start-state name='start'>" + - " <transition to='midway' />" + - " </start-state>" + - " <state name='midway'>" + - " <transition to='end' />" + - " </state>" + - " <end-state name='end' />" + - "</process-definition>"); + ProcessDefinition definition = ProcessDefinition.parseXmlString("<process-definition name='tx'>" + + " <start-state name='start'>" + + " <transition to='midway' />" + + " </start-state>" + + " <state name='midway'>" + + " <transition to='end' />" + + " </state>" + + " <end-state name='end' />" + + "</process-definition>"); jbpmContext.deployProcessDefinition(definition); definitionId = definition.getId(); } - catch (RuntimeException e) - { - if (tx == null) - jbpmContext.setRollbackOnly(); + catch (RuntimeException e) { + if (tx == null) jbpmContext.setRollbackOnly(); throw e; } - finally - { + finally { jbpmContext.close(); } - if (tx != null) - tx.commit(); + if (tx != null) tx.commit(); } - catch (Exception e) - { - if (tx != null) - tx.rollback(); + catch (Exception e) { + if (tx != null) tx.rollback(); throw e; } } return definitionId; } - private long launchProcess(long definitionId) throws Exception - { - try - { - if (tx != null) - tx.begin(); + private long launchProcess(long definitionId) throws Exception { + try { + if (tx != null) tx.begin(); JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); ProcessInstance instance; - try - { + try { assertEquals(tx == null, isTxCreatedByService(jbpmContext)); - ProcessDefinition definition = jbpmContext.getGraphSession().loadProcessDefinition(definitionId); + ProcessDefinition definition = jbpmContext.getGraphSession().loadProcessDefinition( + definitionId); instance = new ProcessInstance(definition); instance.signal(); jbpmContext.save(instance); } - catch (RuntimeException e) - { - if (tx == null) - jbpmContext.setRollbackOnly(); + catch (RuntimeException e) { + if (tx == null) jbpmContext.setRollbackOnly(); throw e; } - finally - { + finally { jbpmContext.close(); } - if (tx != null) - tx.commit(); + if (tx != null) tx.commit(); return instance.getId(); } - catch (Exception e) - { - if (tx != null) - tx.rollback(); + catch (Exception e) { + if (tx != null) tx.rollback(); throw e; } } - private void signal(long instanceId) throws Exception - { - try - { - if (tx != null) - tx.begin(); + private void signal(long instanceId) throws Exception { + try { + if (tx != null) tx.begin(); JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { assertEquals(tx == null, isTxCreatedByService(jbpmContext)); ProcessInstance instance = jbpmContext.loadProcessInstanceForUpdate(instanceId); instance.signal(); - if (rollback && tx == null) - jbpmContext.setRollbackOnly(); + if (rollback && tx == null) jbpmContext.setRollbackOnly(); } - catch (RuntimeException e) - { - if (tx == null) - jbpmContext.setRollbackOnly(); + catch (RuntimeException e) { + if (tx == null) jbpmContext.setRollbackOnly(); throw e; } - finally - { + finally { jbpmContext.close(); } - if (tx != null) - { + if (tx != null) { if (rollback) tx.rollback(); else tx.commit(); } } - catch (Exception e) - { - if (tx != null) - tx.rollback(); + catch (Exception e) { + if (tx != null) tx.rollback(); throw e; } } - private boolean hasEnded(long instanceId) throws Exception - { - try - { - if (tx != null) - tx.begin(); + private boolean hasEnded(long instanceId) throws Exception { + try { + if (tx != null) tx.begin(); JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); ProcessInstance instance; - try - { + try { assertEquals(tx == null, isTxCreatedByService(jbpmContext)); instance = jbpmContext.loadProcessInstanceForUpdate(instanceId); } - catch (RuntimeException e) - { - if (tx == null) - jbpmContext.setRollbackOnly(); + catch (RuntimeException e) { + if (tx == null) jbpmContext.setRollbackOnly(); throw e; } - finally - { + finally { jbpmContext.close(); } - if (tx != null) - tx.commit(); + if (tx != null) tx.commit(); return instance.hasEnded(); } - catch (Exception e) - { - if (tx != null) - tx.rollback(); + catch (Exception e) { + if (tx != null) tx.rollback(); throw e; } } - private boolean isTxCreatedByService(JbpmContext jbpmContext) - { - JtaDbPersistenceService persistenceService = (JtaDbPersistenceService)jbpmContext.getServices().getPersistenceService(); + private boolean isTxCreatedByService(JbpmContext jbpmContext) { + JtaDbPersistenceService persistenceService = (JtaDbPersistenceService) jbpmContext.getServices() + .getPersistenceService(); return persistenceService.isJtaTxCreated(); } - private static UserTransaction getUserTransaction() throws NamingException - { + private static UserTransaction getUserTransaction() throws NamingException { Context initial = new InitialContext(); - return (UserTransaction)initial.lookup("java:comp/UserTransaction"); + return (UserTransaction) initial.lookup("java:comp/UserTransaction"); } } Added: jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/resources/jboss405-dependencies.txt =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/resources/jboss405-dependencies.txt (rev 0) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/enterprise/src/test/resources/jboss405-dependencies.txt 2009-05-04 09:33:28 UTC (rev 4706) @@ -0,0 +1,72 @@ +# This file shows jboss-4.0.5.GA thirdparty dependencies. It was produced running the following command +# +# (ls -1 lib; ls -1 lib/endorsed; ls -1 server/default/lib/) | grep jar | sed s/.jar// | sort -u +# +activation +antlr-2.7.6 +autonumber-plugin +bcel +bindingservice-plugin +bsf +bsh-1.3.0 +bsh-deployer +cglib +commons-collections +commons-httpclient +commons-logging +concurrent +dom4j +getopt +hibernate3 +hsqldb +hsqldb-plugin +javassist +javax.servlet +javax.servlet.jsp +jaxen +jboss +jboss-backport-concurrent +jboss-common +jboss-common-jdbc-wrapper +jboss-hibernate +jboss-j2ee +jboss-jaxrpc +jboss-jca +jboss-jmx +jboss-jsr77 +jboss-jsr88 +jboss-management +jboss-monitoring +jbossmq +jboss-remoting +jboss-remoting-int +jbossretro-rt +jboss-saaj +jboss-serialization +jboss-srp +jbosssx +jboss-system +jboss-transaction +jboss-xml-binding +jmx-adaptor-plugin +jnpserver +joesnmp +jpl-pattern +jpl-util +log4j +log4j-boot +log4j-snmp-appender +mail +mail-plugin +namespace +properties-plugin +resolver +scheduler-plugin +scheduler-plugin-example +serializer +webdavlib +wsdl4j +xalan +xercesImpl +xml-apis +xmlentitymgr Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -2,7 +2,7 @@ <classpath> <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/> <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> <classpathentry kind="output" path="target/classes"/> </classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/assignment/RulesAssignmentTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/assignment/RulesAssignmentTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/assignment/RulesAssignmentTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -43,17 +43,16 @@ /** * This example shows how to invoke JBoss Rules from an AssignmentHandler. */ -public class RulesAssignmentTest extends TestCase -{ +public class RulesAssignmentTest extends TestCase { + JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(); - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); JbpmContext jbpmContext; long processInstanceId; - public void setUp() - { + public void setUp() { dbPersistenceServiceFactory.createSchema(); loadIdentities(); @@ -61,62 +60,50 @@ jbpmContext = jbpmConfiguration.createJbpmContext(); } - protected void tearDown() - { + protected void tearDown() { jbpmContext.close(); dbPersistenceServiceFactory.dropSchema(); jbpmContext = null; } - public void deployProcess() - { + public void deployProcess() { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("assignment/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); } - finally - { + finally { jbpmContext.close(); } } - public void loadIdentities() - { + public void loadIdentities() { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { Entity[] entities = IdentityXmlParser.parseEntitiesResource("assignment/identity.db.xml"); IdentitySession identitySession = new IdentitySession(jbpmContext.getSession()); - for (int i = 0; i < entities.length; i++) - { + for (int i = 0; i < entities.length; i++) { identitySession.saveEntity(entities[i]); } } - finally - { + finally { jbpmContext.close(); } } - public void newTransaction() - { + public void newTransaction() { jbpmContext.close(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void testRulesAssignment() - { + public void testRulesAssignment() { // start process newTransaction(); processInstanceId = createNewProcessInstance(); - assertNotNull(processInstanceId); // perform task newTransaction(); long taskInstanceId = acquireTask("tom"); - assertNotNull(taskInstanceId); newTransaction(); completeTask(taskInstanceId); @@ -134,8 +121,7 @@ } - public long createNewProcessInstance() - { + public long createNewProcessInstance() { String processDefinitionName = "RulesAssignment"; ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate(processDefinitionName); long id = processInstance.getId(); @@ -148,16 +134,14 @@ return id; } - public long acquireTask(String actorId) - { - List<TaskInstance> tasklist = getTaskList(actorId); + public long acquireTask(String actorId) { + List tasklist = getTaskList(actorId); Iterator taskIterator = tasklist.iterator(); TaskInstance taskInstance = null; long taskInstanceId = 0; - while (taskIterator.hasNext()) - { - taskInstance = (TaskInstance)taskIterator.next(); + while (taskIterator.hasNext()) { + taskInstance = (TaskInstance) taskIterator.next(); taskInstanceId = taskInstance.getId(); taskInstance.start(); @@ -165,22 +149,18 @@ return taskInstanceId; } - public void completeTask(long taskInstanceId) - { + public void completeTask(long taskInstanceId) { TaskInstance taskInstance = jbpmContext.getTaskInstance(taskInstanceId); taskInstance.end(); } - public List<TaskInstance> getTaskList(String actorId) - { + public List getTaskList(String actorId) { newTransaction(); - List<TaskInstance> taskList = jbpmContext.getTaskList(actorId); - return taskList; + return jbpmContext.getTaskList(actorId); } - public ProcessInstance getProcessInstance(long processInstanceId) - { - ProcessInstance processInstance = (ProcessInstance)jbpmContext.loadProcessInstanceForUpdate(processInstanceId); + public ProcessInstance getProcessInstance(long processInstanceId) { + ProcessInstance processInstance = (ProcessInstance) jbpmContext.loadProcessInstanceForUpdate(processInstanceId); return processInstance; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/businesstrip/BusinessTripRequestTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/businesstrip/BusinessTripRequestTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/businesstrip/BusinessTripRequestTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; import org.jbpm.context.exe.ContextInstance; @@ -18,12 +19,12 @@ import org.jbpm.taskmgmt.exe.TaskInstance; import org.jbpm.taskmgmt.exe.TaskMgmtInstance; -public class BusinessTripRequestTest extends TestCase -{ +public class BusinessTripRequestTest extends TestCase { + Log log = LogFactory.getLog(this.getClass()); JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(); - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); JbpmContext jbpmContext; @@ -32,42 +33,35 @@ TaskMgmtInstance taskMgmtInstance; long processInstanceId = -1; - public void setUp() - { + public void setUp() { dbPersistenceServiceFactory.createSchema(); deployProcess(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void tearDown() - { + public void tearDown() { jbpmContext.close(); dbPersistenceServiceFactory.dropSchema(); jbpmContext = null; } - private void newTransaction() - { + private void newTransaction() { jbpmContext.close(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - private void deployProcess() - { + private void deployProcess() { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("businesstrip/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); } - finally - { + finally { jbpmContext.close(); } } - private TaskInstance createNewProcessInstance() - { + private TaskInstance createNewProcessInstance() { processInstance = jbpmContext.newProcessInstanceForUpdate("business trip request"); processInstanceId = processInstance.getId(); contextInstance = processInstance.getContextInstance(); @@ -75,47 +69,47 @@ return processInstance.getTaskMgmtInstance().createStartTaskInstance(); } - public void testTaskParameters() - { + public void testTaskParameters() { TaskInstance taskInstance = createNewProcessInstance(); assertEquals("submit business trip request", taskInstance.getName()); assertEquals(0, taskInstance.getVariables().size()); } - public void testSubmitRaiseRequestTask() - { + public void testSubmitRaiseRequestTask() { jbpmContext.setActorId("employee"); TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("purpose", "Conference in MIT"); - taskVariables.put("description", "This conference is mainly to highlight to impact of ESB technologies on the current industries"); - taskVariables.put("allocated budget", 3000); + taskVariables.put("description", + "This conference is mainly to highlight to impact of ESB technologies on the current industries"); + taskVariables.put("allocated budget", "3000"); taskVariables.put("start date", "8/12/2009"); taskVariables.put("end date", "8/21/2009"); taskInstance.addVariables(taskVariables); taskInstance.end(); assertEquals("Conference in MIT", contextInstance.getVariable("purpose")); - assertEquals("This conference is mainly to highlight to impact of ESB technologies on the current industries", contextInstance.getVariable("description")); - assertEquals(3000, contextInstance.getVariable("allocated budget")); + assertEquals( + "This conference is mainly to highlight to impact of ESB technologies on the current industries", + contextInstance.getVariable("description")); + assertEquals("3000", contextInstance.getVariable("allocated budget")); assertEquals("8/12/2009", contextInstance.getVariable("start date")); assertEquals("8/21/2009", contextInstance.getVariable("end date")); assertEquals("employee", taskMgmtInstance.getSwimlaneInstance("employee").getActorId()); } - @SuppressWarnings("unchecked") - public void testRejectBusinessTripRequest() - { + public void testRejectBusinessTripRequest() { // Employee submits a business trip request jbpmContext.setActorId("employee"); TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("purpose", "Conference in MIT"); - taskVariables.put("description", "This conference is mainly to highlight to impact of ESB technologies on the current industries"); - taskVariables.put("allocated budget", 3000); + taskVariables.put("description", + "This conference is mainly to highlight to impact of ESB technologies on the current industries"); + taskVariables.put("allocated budget", "3000"); taskVariables.put("start date", "8/12/2009"); taskVariables.put("end date", "8/21/2009"); @@ -126,28 +120,26 @@ // Manager rejects the raise request newTransaction(); - log.info(jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(processInstance).size()); - List<TaskInstance> managerTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasksList.size()); - TaskInstance managerTask = managerTasksList.get(0); + TaskInstance managerTask = (TaskInstance) managerTasksList.get(0); managerTask.addComment("Conference theme doesn't align with company's current focus"); managerTask.end("reject"); assertEquals("manager", managerTask.getActorId()); } - @SuppressWarnings("unchecked") - public void testAcceptBusinessTripRequest() - { + public void testAcceptBusinessTripRequest() { // Employee submits a raise request jbpmContext.setActorId("employee"); TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("purpose", "Conference in MIT"); - taskVariables.put("description", "This conference is mainly to highlight to impact of ESB technologies on the current industries"); - taskVariables.put("allocated budget", 3000); + taskVariables.put("description", + "This conference is mainly to highlight to impact of ESB technologies on the current industries"); + taskVariables.put("allocated budget", new Long(3000)); taskVariables.put("start date", "8/12/2009"); taskVariables.put("end date", "8/21/2009"); taskVariables.put("country", "USA"); @@ -159,19 +151,19 @@ // Manager rejects the raise request newTransaction(); - List<TaskInstance> managerTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasksList.size()); - TaskInstance managerTask = managerTasksList.get(0); + TaskInstance managerTask = (TaskInstance) managerTasksList.get(0); managerTask.addComment("Business trip approved"); managerTask.end("approve"); assertEquals("manager", managerTask.getActorId()); jbpmContext.save(managerTask); newTransaction(); - List<TaskInstance> accountantTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); + List accountantTasksList = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); assertEquals(1, accountantTasksList.size()); - TaskInstance accountantTask = accountantTasksList.get(0); + TaskInstance accountantTask = (TaskInstance) accountantTasksList.get(0); accountantTask.end(); jbpmContext.save(accountantTask); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/raise/RaiseRequestTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/raise/RaiseRequestTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/raise/RaiseRequestTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; import org.jbpm.context.exe.ContextInstance; @@ -18,12 +19,12 @@ import org.jbpm.taskmgmt.exe.TaskInstance; import org.jbpm.taskmgmt.exe.TaskMgmtInstance; -public class RaiseRequestTest extends TestCase -{ +public class RaiseRequestTest extends TestCase { + Log log = LogFactory.getLog(this.getClass()); JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(); - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); JbpmContext jbpmContext; @@ -32,42 +33,35 @@ TaskMgmtInstance taskMgmtInstance = null; long processInstanceId = -1; - public void setUp() - { + public void setUp() { dbPersistenceServiceFactory.createSchema(); deployProcess(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void tearDown() - { + public void tearDown() { jbpmContext.close(); dbPersistenceServiceFactory.dropSchema(); jbpmContext = null; } - private void newTransaction() - { + private void newTransaction() { jbpmContext.close(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - private void deployProcess() - { + private void deployProcess() { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("raise/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); } - finally - { + finally { jbpmContext.close(); } } - private TaskInstance createNewProcessInstance() - { + private TaskInstance createNewProcessInstance() { processInstance = jbpmContext.newProcessInstanceForUpdate("raise request"); processInstanceId = processInstance.getId(); contextInstance = processInstance.getContextInstance(); @@ -75,75 +69,69 @@ return processInstance.getTaskMgmtInstance().createStartTaskInstance(); } - public void testTaskParameters() - { + public void testTaskParameters() { TaskInstance taskInstance = createNewProcessInstance(); assertEquals("submit raise request", taskInstance.getName()); assertEquals(0, taskInstance.getVariables().size()); } - public void testSubmitRaiseRequestTask() - { + public void testSubmitRaiseRequestTask() { jbpmContext.setActorId("employee"); TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("reason", "I need to buy a jet"); - taskVariables.put("amount", 600); + taskVariables.put("amount", "600"); taskInstance.addVariables(taskVariables); taskInstance.end(); assertEquals("I need to buy a jet", contextInstance.getVariable("reason")); - assertEquals(600, contextInstance.getVariable("amount")); + assertEquals("600", contextInstance.getVariable("amount")); assertEquals("employee", taskMgmtInstance.getSwimlaneInstance("employee").getActorId()); } - @SuppressWarnings("unchecked") - public void testManagerEvaluationReject() - { + public void testManagerEvaluationReject() { TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("reason", "I need to buy a jet"); - taskVariables.put("amount", 600); + taskVariables.put("amount", "600"); taskInstance.addVariables(taskVariables); taskInstance.end(); jbpmContext.save(processInstance); newTransaction(); - List<TaskInstance> managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasks.size()); - TaskInstance managerTask = managerTasks.get(0); + TaskInstance managerTask = (TaskInstance) managerTasks.get(0); managerTask.end("reject"); - List<TaskInstance> foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); + List foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); assertEquals(0, foTasks.size()); } - @SuppressWarnings("unchecked") - public void testManagerEvaluationAcceptFOReject() - { + public void testManagerEvaluationAcceptFOReject() { TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("reason", "I need to buy a jet"); - taskVariables.put("amount", 600); + taskVariables.put("amount", "600"); taskInstance.addVariables(taskVariables); taskInstance.end(); jbpmContext.save(processInstance); newTransaction(); - List<TaskInstance> managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasks.size()); - TaskInstance managerTask = managerTasks.get(0); + TaskInstance managerTask = (TaskInstance) managerTasks.get(0); managerTask.start(); managerTask.end("accept"); newTransaction(); - List<TaskInstance> foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); + List foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); assertEquals(1, foTasks.size()); - TaskInstance foTask = foTasks.get(0); + TaskInstance foTask = (TaskInstance) foTasks.get(0); foTask.start(); foTask.addComment("Justify two consecutive raises"); foTask.end("reject"); @@ -152,66 +140,62 @@ assertEquals(0, managerTasks.size()); } - @SuppressWarnings("unchecked") - public void testManagerEvaluationAcceptFOAccpet() - { + public void testManagerEvaluationAcceptFOAccpet() { TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("reason", "I need to buy a jet"); - taskVariables.put("amount", 600); + taskVariables.put("amount", "600"); taskInstance.addVariables(taskVariables); taskInstance.end(); jbpmContext.save(processInstance); newTransaction(); - List<TaskInstance> managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasks.size()); - TaskInstance managerTask = managerTasks.get(0); + TaskInstance managerTask = (TaskInstance) managerTasks.get(0); managerTask.start(); managerTask.end("accept"); newTransaction(); - List<TaskInstance> foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); + List foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); assertEquals(1, foTasks.size()); - TaskInstance foTask = foTasks.get(0); + TaskInstance foTask = (TaskInstance) foTasks.get(0); foTask.start(); foTask.addComment("Justify two consecutive raises"); foTask.end("accept"); newTransaction(); - List<TaskInstance> accountantTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); + List accountantTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); assertEquals(1, accountantTasks.size()); - TaskInstance accountantTask = accountantTasks.get(0); + TaskInstance accountantTask = (TaskInstance) accountantTasks.get(0); accountantTask.start(); accountantTask.addComment("ERP updated"); accountantTask.end("terminate"); } - @SuppressWarnings("unchecked") - public void testManagerEvaluationAcceptFOMultipleIterationsAccpet() - { + public void testManagerEvaluationAcceptFOMultipleIterationsAccpet() { TaskInstance taskInstance = createNewProcessInstance(); - Map<String, Object> taskVariables = new HashMap<String, Object>(); + Map taskVariables = new HashMap(); taskVariables.put("reason", "I need to buy a jet"); - taskVariables.put("amount", 600); + taskVariables.put("amount", "600"); taskInstance.addVariables(taskVariables); taskInstance.end(); jbpmContext.save(processInstance); newTransaction(); - List<TaskInstance> managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); + List managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasks.size()); - TaskInstance managerTask = managerTasks.get(0); + TaskInstance managerTask = (TaskInstance) managerTasks.get(0); managerTask.start(); managerTask.end("accept"); newTransaction(); - List<TaskInstance> foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); + List foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); assertEquals(1, foTasks.size()); - TaskInstance foTask = foTasks.get(0); + TaskInstance foTask = (TaskInstance) foTasks.get(0); foTask.start(); foTask.addComment("Justify two consecutive raises"); foTask.end("more justification required"); @@ -220,7 +204,7 @@ managerTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("manager"); assertEquals(1, managerTasks.size()); - managerTask = managerTasks.get(0); + managerTask = (TaskInstance) managerTasks.get(0); managerTask.start(); managerTask.addComment("The guy exceeds all the expectations"); managerTask.end("accept"); @@ -229,16 +213,16 @@ foTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("fo"); assertEquals(1, foTasks.size()); - foTask = foTasks.get(0); + foTask = (TaskInstance) foTasks.get(0); foTask.start(); foTask.addComment("justification accepted"); foTask.end("accept"); newTransaction(); - List<TaskInstance> accountantTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); + List accountantTasks = jbpmContext.getTaskMgmtSession().findTaskInstances("accountant"); assertEquals(1, accountantTasks.size()); - TaskInstance accountantTask = accountantTasks.get(0); + TaskInstance accountantTask = (TaskInstance) accountantTasks.get(0); accountantTask.start(); accountantTask.addComment("ERP updated"); accountantTask.end("terminate"); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/rulesaction/RulesActionTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/rulesaction/RulesActionTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/rulesaction/RulesActionTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -30,63 +30,54 @@ import org.jbpm.context.exe.ContextInstance; import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.graph.exe.Token; import org.jbpm.persistence.db.DbPersistenceServiceFactory; import org.jbpm.svc.Services; -import org.jbpm.graph.exe.Token; /** * This example shows how to invoke JBoss Drools from an ActionHandler. */ -public class RulesActionTest extends TestCase -{ +public class RulesActionTest extends TestCase { JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(); - DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + DbPersistenceServiceFactory dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); JbpmContext jbpmContext; long processInstanceId; - public void setUp() - { + public void setUp() { dbPersistenceServiceFactory.createSchema(); deployProcess(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void tearDown() - { + public void tearDown() { jbpmContext.close(); dbPersistenceServiceFactory.dropSchema(); jbpmContext = null; } - public void newTransaction() - { + public void newTransaction() { jbpmContext.close(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void deployProcess() - { + public void deployProcess() { JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("rulesaction/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); } - finally - { + finally { jbpmContext.close(); } } - public void testRulesAssignment() - { + public void testRulesAssignment() { // start process newTransaction(); processInstanceId = createNewProcessInstance(); - assertNotNull(processInstanceId); newTransaction(); ProcessInstance processInstance = getProcessInstance(processInstanceId); @@ -95,13 +86,12 @@ Date processEnd = processInstance.getEnd(); assertNotNull(processEnd); - String shipper = (String)processInstance.getContextInstance().getVariable("shipper"); + String shipper = (String) processInstance.getContextInstance().getVariable("shipper"); assertEquals("shipper is FEDX", shipper, "FEDX"); } - public long createNewProcessInstance() - { + public long createNewProcessInstance() { String processDefinitionName = "RulesAction"; ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate(processDefinitionName); long id = processInstance.getId(); @@ -116,9 +106,8 @@ return id; } - public ProcessInstance getProcessInstance(long processInstanceId) - { - ProcessInstance processInstance = (ProcessInstance)jbpmContext.loadProcessInstanceForUpdate(processInstanceId); + public ProcessInstance getProcessInstance(long processInstanceId) { + ProcessInstance processInstance = (ProcessInstance) jbpmContext.loadProcessInstanceForUpdate(processInstanceId); return processInstance; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/taskinstance/CustomTaskInstanceTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/taskinstance/CustomTaskInstanceTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/examples/src/test/java/org/jbpm/examples/taskinstance/CustomTaskInstanceTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -29,6 +29,7 @@ import org.hibernate.Query; import org.hibernate.Session; + import org.jbpm.JbpmConfiguration; import org.jbpm.JbpmContext; import org.jbpm.context.exe.ContextInstance; @@ -45,8 +46,7 @@ /** * This example shows how to extend the TaskInstance by adding a custom property. */ -public class CustomTaskInstanceTest extends TestCase -{ +public class CustomTaskInstanceTest extends TestCase { JbpmConfiguration jbpmConfiguration = null; // JbpmConfiguration.getInstance(); @@ -61,14 +61,13 @@ ContextInstance contextInstance = null; - public void setUp() - { + public void setUp() { // the jbpm.cfg.xml file is modified to add the CustomTaskInstanceFactory // so we will read in the file from the config directory of this example jbpmConfiguration = JbpmConfiguration.parseResource("taskinstance/jbpm.cfg.xml"); - dbPersistenceServiceFactory = (DbPersistenceServiceFactory)jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); + dbPersistenceServiceFactory = (DbPersistenceServiceFactory) jbpmConfiguration.getServiceFactory(Services.SERVICENAME_PERSISTENCE); // the CustomTaskInstance mapping file reference // <mapping resource="org/jbpm/taskinstance/CustomTaskInstance.hbm.xml"/> @@ -83,63 +82,51 @@ jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void tearDown() - { + public void tearDown() { jbpmContext.close(); dbPersistenceServiceFactory.dropSchema(); jbpmContext = null; } - public void newTransaction() - { + public void newTransaction() { jbpmContext.close(); jbpmContext = jbpmConfiguration.createJbpmContext(); } - public void deployProcess() - { + public void deployProcess() { jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("taskinstance/processdefinition.xml"); jbpmContext.deployProcessDefinition(processDefinition); } - finally - { + finally { jbpmContext.close(); } } - public void loadIdentities() - { + public void loadIdentities() { jbpmContext = jbpmConfiguration.createJbpmContext(); - try - { + try { Entity[] entities = IdentityXmlParser.parseEntitiesResource("identity.db.xml"); IdentitySession identitySession = new IdentitySession(jbpmContext.getSession()); - for (int i = 0; i < entities.length; i++) - { + for (int i = 0; i < entities.length; i++) { identitySession.saveEntity(entities[i]); } } - finally - { + finally { jbpmContext.close(); } } - public void testCustomTaskInstance() - { + public void testCustomTaskInstance() { // create processInstance newTransaction(); long processInstanceId = createNewProcessInstance(); - assertNotNull(processInstanceId); assertFalse("ProcessInstanceId is 0", processInstanceId == 0); // perform the task newTransaction(); long taskInstanceId = acquireTask(); - assertNotNull(taskInstanceId); assertFalse("TaskInstanceId is 0", taskInstanceId == 0); newTransaction(); @@ -158,8 +145,7 @@ assertNotNull(processEnd); } - public long createNewProcessInstance() - { + public long createNewProcessInstance() { String processDefinitionName = "CustomTaskInstance"; processInstance = jbpmContext.newProcessInstanceForUpdate(processDefinitionName); long processInstanceId = processInstance.getId(); @@ -172,17 +158,15 @@ } - public long acquireTask() - { + public long acquireTask() { - List<CustomTaskInstance> tasklist = findPooledTaskListByCustomId("reviewers", "abc"); + List tasklist = findPooledTaskListByCustomId("reviewers", "abc"); Iterator taskIterator = tasklist.iterator(); CustomTaskInstance taskInstance = null; long taskInstanceId = 0; - while (taskIterator.hasNext()) - { - taskInstance = (CustomTaskInstance)taskIterator.next(); + while (taskIterator.hasNext()) { + taskInstance = (CustomTaskInstance) taskIterator.next(); taskInstanceId = taskInstance.getId(); taskInstance.start(); taskInstance.setActorId("tom"); @@ -192,23 +176,24 @@ return taskInstanceId; } - public void completeTask(long taskInstanceId) - { + public void completeTask(long taskInstanceId) { s = jbpmContext.getSession(); - CustomTaskInstance taskInstance = (CustomTaskInstance)s.load(CustomTaskInstance.class, new Long(taskInstanceId)); + CustomTaskInstance taskInstance = (CustomTaskInstance) s.load(CustomTaskInstance.class, + new Long(taskInstanceId)); taskInstance.end(); } - private static final String findPooledTaskInstancesByCustomId = - "select distinct ti " + "from " + CustomTaskInstance.class.getName() + " ti " + - " join ti.pooledActors pooledActor where pooledActor.actorId = :pooledActorId and ti.actorId is null and ti.end is null " + - " and ti.isCancelled = false and ti.customId = :customId"; + private static final String findPooledTaskInstancesByCustomId = "select distinct ti " + + "from " + + CustomTaskInstance.class.getName() + + " ti " + + " join ti.pooledActors pooledActor where pooledActor.actorId = :pooledActorId and ti.actorId is null and ti.end is null " + + " and ti.isCancelled = false and ti.customId = :customId"; - public List<CustomTaskInstance> findPooledTaskListByCustomId(String actorId, String customId) - { - List<CustomTaskInstance> taskList = null; + public List findPooledTaskListByCustomId(String actorId, String customId) { + List taskList = null; s = jbpmContext.getSession(); Query query = s.createQuery(findPooledTaskInstancesByCustomId); query.setString("pooledActorId", actorId); Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/identity/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/identity/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/identity/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,7 +4,7 @@ <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/> <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> <classpathentry kind="output" path="target/classes"/> </classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -35,8 +35,7 @@ import org.jbpm.taskmgmt.exe.SwimlaneInstance; import org.jbpm.taskmgmt.exe.TaskInstance; -public class ExpressionAssignmentHandlerTest extends IdentityDbTestCase -{ +public class ExpressionAssignmentHandlerTest extends IdentityDbTestCase { ExpressionAssignmentHandler expressionAssignmentHandler; TaskInstance assignable = new TaskInstance(); @@ -47,9 +46,8 @@ Membership membershipJohn, membershipBill; Group hellsangels; User john, bill; - - public void setUp() throws Exception - { + + public void setUp() throws Exception { super.setUp(); expressionAssignmentHandler = new ExpressionAssignmentHandler(); setUpProcessInstance(); @@ -58,9 +56,7 @@ jbpmContext.setActorId("bill"); } - @Override - protected void tearDown() throws Exception - { + protected void tearDown() throws Exception { deleteUser(john.getId()); deleteUser(bill.getId()); deleteGroup(hellsangels.getId()); @@ -68,8 +64,7 @@ super.tearDown(); } - private void setUpUserData() - { + private void setUpUserData() { john = new User("john"); bill = new User("bill"); hellsangels = new Group("hellsangels", "hierarchy"); @@ -83,30 +78,25 @@ identitySession.saveMembership(membershipBill); } - private void setUpProcessInstance() - { + private void setUpProcessInstance() { processDefinition = ProcessDefinition.parseXmlString("<process-definition/>"); graphSession.saveProcessDefinition(processDefinition); processInstance = new ProcessInstance(processDefinition); jbpmContext.save(processInstance); } - - @Override - protected void newTransaction() - { + + protected void newTransaction() { super.newTransaction(); executionContext = new ExecutionContext(processInstance.getRootToken()); } - - public void testFirstTermPrevious() - { + + public void testFirstTermPrevious() { expressionAssignmentHandler.expression = "previous"; expressionAssignmentHandler.assign(assignable, executionContext); assertEquals("bill", assignable.getActorId()); } - public void testFirstTermSwimlane() - { + public void testFirstTermSwimlane() { expressionAssignmentHandler.expression = "swimlane(boss)"; SwimlaneInstance swimlaneInstance = new SwimlaneInstance(new Swimlane("boss")); swimlaneInstance.setActorId("john"); @@ -115,30 +105,25 @@ assertEquals("john", assignable.getActorId()); } - public void testFirstTermSwimlaneUnexisting() - { + public void testFirstTermSwimlaneUnexisting() { expressionAssignmentHandler.expression = "swimlane(sillywoman)"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } - public void testFirstTermVariableString() - { + public void testFirstTermVariableString() { expressionAssignmentHandler.expression = "variable(actoridstringvariable)"; processInstance.getContextInstance().setVariable("actoridstringvariable", "john"); expressionAssignmentHandler.assign(assignable, executionContext); assertEquals("john", assignable.getActorId()); } - public void testFirstTermVariableUser() - { + public void testFirstTermVariableUser() { expressionAssignmentHandler.expression = "variable(uservariable)"; User john = identitySession.getUserByName("john"); processInstance.getContextInstance().setVariable("uservariable", john); @@ -146,115 +131,95 @@ assertEquals("john", assignable.getActorId()); } - public void testFirstTermVariableGroup() - { + public void testFirstTermVariableGroup() { expressionAssignmentHandler.expression = "variable(groupvariable)"; Group hellsangels = identitySession.getGroupByName("hellsangels"); processInstance.getContextInstance().setVariable("groupvariable", hellsangels); expressionAssignmentHandler.assign(assignable, executionContext); Set pooledActors = assignable.getPooledActors(); - PooledActor pooledActor = (PooledActor)pooledActors.iterator().next(); + PooledActor pooledActor = (PooledActor) pooledActors.iterator().next(); assertEquals("hellsangels", pooledActor.getActorId()); } - public void testFirstTermVariableUnexisting() - { + public void testFirstTermVariableUnexisting() { expressionAssignmentHandler.expression = "variable(unexistingvariablename)"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } - public void testFirstTermUser() - { + public void testFirstTermUser() { expressionAssignmentHandler.expression = "user(john)"; expressionAssignmentHandler.assign(assignable, executionContext); assertEquals("john", assignable.getActorId()); } - public void testFirstTermUserUnexisting() - { + public void testFirstTermUserUnexisting() { expressionAssignmentHandler.expression = "user(idontexist)"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } - public void testFirstTermGroup() - { + public void testFirstTermGroup() { expressionAssignmentHandler.expression = "group(hellsangels)"; expressionAssignmentHandler.assign(assignable, executionContext); Set pooledActors = assignable.getPooledActors(); - PooledActor pooledActor = (PooledActor)pooledActors.iterator().next(); + PooledActor pooledActor = (PooledActor) pooledActors.iterator().next(); assertEquals("hellsangels", pooledActor.getActorId()); } - public void testFirstTermGroupUnexisting() - { + public void testFirstTermGroupUnexisting() { expressionAssignmentHandler.expression = "group(wedontexist)"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } - public void testWrongFirstTerm() - { + public void testWrongFirstTerm() { expressionAssignmentHandler.expression = "wrong-first-term"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } - public void testNextTermGroup() - { + public void testNextTermGroup() { expressionAssignmentHandler.expression = "user(john) --> group(hierarchy)"; expressionAssignmentHandler.assign(assignable, executionContext); Set pooledActors = assignable.getPooledActors(); - PooledActor pooledActor = (PooledActor)pooledActors.iterator().next(); + PooledActor pooledActor = (PooledActor) pooledActors.iterator().next(); assertEquals("hellsangels", pooledActor.getActorId()); } - public void testNextTermMember() - { + public void testNextTermMember() { expressionAssignmentHandler.expression = "group(hellsangels) --> member(leaderofthegang)"; expressionAssignmentHandler.assign(assignable, executionContext); assertEquals("john", assignable.getActorId()); } - public void testWrongNextTerm() - { + public void testWrongNextTerm() { expressionAssignmentHandler.expression = "user(john) --> wrong-second-term"; - try - { + try { expressionAssignmentHandler.assign(assignable, executionContext); fail("expected exception"); } - catch (ExpressionAssignmentException e) - { + catch (ExpressionAssignmentException e) { // OK } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -31,11 +31,9 @@ import org.jbpm.identity.Membership; import org.jbpm.identity.User; -public class UserDbTest extends IdentityDbTestCase -{ +public class UserDbTest extends IdentityDbTestCase { - public void testUser() - { + public void testUser() { User user = new User("johndoe"); user = saveAndReload(user); assertEquals("johndoe", user.getName()); @@ -43,8 +41,7 @@ deleteUser(user.getId()); } - public void testUserMemberships() - { + public void testUserMemberships() { User john = new User("johndoe"); Group qaTeam = new Group("qa team", "hierarchy"); Group marketingTeam = new Group("marketing team", "hierarchy"); @@ -65,8 +62,7 @@ deleteUser(john.getId()); } - public void testUserPermissions() - { + public void testUserPermissions() { User user = new User("johndoe"); user.addPermission(new NetPermission("connect", "9001")); user.addPermission(new AllPermission("all", "everything")); @@ -80,33 +76,26 @@ deleteUser(user.getId()); } - public void testVerifyWrongUser() - { + public void testVerifyWrongUser() { assertNull(identitySession.verify("unexisting-user", "wrong password")); } - public void testVerifyValidPwd() - { + public void testVerifyValidPwd() { User user = new User("johndoe"); user.setPassword("johnspwd"); user = saveAndReload(user); - try - { - assertEquals(user.getId(), identitySession.verify("johndoe", "johnspwd")); + try { + assertEquals(new Long(user.getId()), identitySession.verify("johndoe", "johnspwd")); } - finally - { + finally { deleteUser(user.getId()); } } - private boolean containsGroup(Set groups, String groupName) - { - Iterator iter = groups.iterator(); - while (iter.hasNext()) - { - if (groupName.equals(((Group)iter.next()).getName())) - { + private boolean containsGroup(Set groups, String groupName) { + for (Iterator i = groups.iterator(); i.hasNext();) { + Group group = (Group) i.next(); + if (groupName.equals(group.getName())) { return true; } } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,7 +4,7 @@ <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/> <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> <classpathentry kind="output" path="target/classes"/> </classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/jpdl/SimulationDefinition.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/jpdl/SimulationDefinition.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/jpdl/SimulationDefinition.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; + import org.jbpm.graph.def.Node; import org.jbpm.graph.def.Transition; import org.jbpm.module.def.ModuleDefinition; @@ -23,48 +24,41 @@ * this object is populated during instrumentation (see SimulationTestCase) * * @author bernd.ruecker(a)camunda.com - */ + */ public class SimulationDefinition extends ModuleDefinition { private static final long serialVersionUID = 1L; - + private static Log log = LogFactory.getLog(SimulationDefinition.class); - + // Map<Object (process elements), Object (any simulation configuration information)> // Map simulationConfiguration; - + /** - * Map containing pool definitions. - * The pool name is the key, the value is an Object array - * with the first element: size as Integer, - * and the second element: costsPerTimeUnit as Double + * Map containing pool definitions. The pool name is the key, the value is an Object array with + * the first element: size as Integer, and the second element: costsPerTimeUnit as Double */ private Map resourcePoolDefinitions = new HashMap(); - + private List distributions = new ArrayList(); - + /** - * maps for process elements which distribution to use - * The key is the process element, the value the distribution name + * maps for process elements which distribution to use The key is the process element, the value + * the distribution name */ - private Map distributionMap = new HashMap(); + private Map distributionMap = new HashMap(); /** - * Map which contains a list of resource requirements for - * process elements (for example Task's or State's) - * - * It is a Map<Object, List> + * Map which contains a list of resource requirements for process elements (for example Task's or + * State's) It is a Map<Object, List> */ - private Map resourceRequirements = new HashMap(); - + private Map resourceRequirements = new HashMap(); + /** - * Map which contains configured probabilities - * for Transitions - * - * It is a Map<Transition, Double> + * Map which contains configured probabilities for Transitions It is a Map<Transition, Double> */ - private Map transitionProbabilities = new HashMap(); - + private Map transitionProbabilities = new HashMap(); + private Map dataSources = new HashMap(); private Map dataFilters = new HashMap(); @@ -74,26 +68,40 @@ } /** - * adds a resource pool. If the pool already exists, the bigger pool - * size is taken. + * adds a resource pool. If the pool already exists, the bigger pool size is taken. * * @param poolName * @param poolSize */ public void addResourcePool(String poolName, Integer poolSize, Double costPerTimeUnit) { - if (resourcePoolDefinitions.containsKey(poolName)) { - Integer otherPoolSize = (Integer)((Object[])resourcePoolDefinitions.get(poolName))[0]; - if (poolSize.intValue() > otherPoolSize.intValue() ) { - resourcePoolDefinitions.put(poolName, new Object[] {poolSize, costPerTimeUnit}); - log.warn("resource pool '" + poolName + "' redefined in process '"+ getProcessDefinition().getName() +"' with the bigger poolsize " + poolSize + ", was " + otherPoolSize + " before" ); + if (resourcePoolDefinitions.containsKey(poolName)) { + Integer otherPoolSize = (Integer) ((Object[]) resourcePoolDefinitions.get(poolName))[0]; + if (poolSize.intValue() > otherPoolSize.intValue()) { + resourcePoolDefinitions.put(poolName, new Object[] { poolSize, costPerTimeUnit }); + log.warn("resource pool '" + + poolName + + "' redefined in process '" + + getProcessDefinition().getName() + + "' with the bigger poolsize " + + poolSize + + ", was " + + otherPoolSize + + " before"); } - else if (poolSize.intValue() < otherPoolSize.intValue() ) - log.warn("resource pool '" + poolName + "' redefined in process '"+ getProcessDefinition().getName() +"' with the smaler poolsize " + poolSize + " which is ignored. Poolsize still is " + otherPoolSize); + else if (poolSize.intValue() < otherPoolSize.intValue()) + log.warn("resource pool '" + + poolName + + "' redefined in process '" + + getProcessDefinition().getName() + + "' with the smaler poolsize " + + poolSize + + " which is ignored. Poolsize still is " + + otherPoolSize); } else - resourcePoolDefinitions.put(poolName, new Object[] {poolSize, costPerTimeUnit}); + resourcePoolDefinitions.put(poolName, new Object[] { poolSize, costPerTimeUnit }); } - + /** * adds a resource pool. If the pool already exists it is overwritten * @@ -101,24 +109,24 @@ * @param poolSize */ public void overwriteResourcePool(String poolName, Integer poolSize, Double costPerTimeUnit) { - resourcePoolDefinitions.put(poolName, new Object[] {poolSize, costPerTimeUnit}); - } - + resourcePoolDefinitions.put(poolName, new Object[] { poolSize, costPerTimeUnit }); + } + public void addResourceRequirement(Object processElement, String poolName, int amount) { List reqList = (List) resourceRequirements.get(processElement); if (reqList == null) { reqList = new ArrayList(); resourceRequirements.put(processElement, reqList); } - reqList.add( new ResourceRequirement(poolName, amount) ); - } + reqList.add(new ResourceRequirement(poolName, amount)); + } /** * adds a distribution. * * @param distDef */ - public void addDistribution(DistributionDefinition distDef) { + public void addDistribution(DistributionDefinition distDef) { distributions.add(distDef); } @@ -131,8 +139,7 @@ // delete all distributions with that name for (Iterator iterator = new ArrayList(distributions).iterator(); iterator.hasNext();) { DistributionDefinition dd = (DistributionDefinition) iterator.next(); - if (dd.getName().equals(distDef.getName())) - distributions.remove(dd); + if (dd.getName().equals(distDef.getName())) distributions.remove(dd); } // and add the new one distributions.add(distDef); @@ -144,8 +151,8 @@ private void addToDistributionMap(Object key, String distributionName) { distributionMap.put(key, distributionName); - } - + } + public void setStartDistribution(String distributionName) { addToDistributionMap(processDefinition, distributionName); } @@ -167,7 +174,7 @@ } public void addTransitionProbability(Transition trans, double prob) { - transitionProbabilities.put(trans, Double.valueOf(prob)); + transitionProbabilities.put(trans, new Double(prob)); } public Map getTransitionProbabilities() { @@ -188,7 +195,7 @@ public ProcessDataSource getDataSource(String name) { ProcessDataSource result = (ProcessDataSource) dataSources.get(name); - if (result==null) + if (result == null) throw new ExperimentConfigurationException("data source '" + name + "' not configured"); return result; } @@ -199,7 +206,7 @@ public ProcessDataFilter getDataFilter(String name) { ProcessDataFilter result = (ProcessDataFilter) dataFilters.get(name); - if (result==null) + if (result == null) throw new ExperimentConfigurationException("data filter '" + name + "' not configured"); return result; } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/report/ScenarioReport.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/report/ScenarioReport.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/main/java/org/jbpm/sim/report/ScenarioReport.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -6,8 +6,7 @@ import java.util.Map; import org.dom4j.Document; -import org.dom4j.DocumentHelper; -import org.dom4j.Element; + import org.jbpm.sim.def.DistributionDefinition; import org.jbpm.sim.report.dto.BaseResult; import org.jbpm.sim.report.dto.CountResult; @@ -17,22 +16,20 @@ import org.jbpm.sim.report.dto.ValueStatisticResult; /** - * This class holds simulation run details - * (as simple POJOs) for a special scenario + * This class holds simulation run details (as simple POJOs) for a special scenario * * @author bernd.ruecker(a)camunda.com */ public class ScenarioReport { - + private String scenarioName; - private double simulationRunTime; + private double simulationRunTime; - private double resetTime; + private double resetTime; /** - * all ValueStatisticResult objects for waiting time - * before states / tasks. + * all ValueStatisticResult objects for waiting time before states / tasks. */ private Map stateWaitingTimes = new HashMap(); @@ -40,7 +37,7 @@ * all ValueStatisticResult objects for process cycle times */ private Map cycleTimesValueStatistics = new HashMap(); - + /** * other ValueStatisticResult objects */ @@ -51,9 +48,9 @@ private Map miscQueueStatistics = new HashMap(); private Map resourcePoolTimeSeries = new HashMap(); - + private Map distributionDefinitions = new HashMap(); - + private Map businessFigureValues = new HashMap(); private Map processEndCounts = new HashMap(); @@ -70,30 +67,29 @@ } public void addMiscValueStatistics(ValueStatisticResult vsr) { - miscValueStatistics.put(vsr.getName(), vsr); + miscValueStatistics.put(vsr.getName(), vsr); } - + public void addResourcePoolWaitingTimes(QueueStatisticsResult qsr) { resourcePoolWaitingTimes.put(qsr.getName(), qsr); } public void addMiscQueueStatistics(QueueStatisticsResult qsr) { miscQueueStatistics.put(qsr.getName(), qsr); - } + } - public void addResourcePoolUtilization(BaseResult usr) { - resourcePoolUtilizations.put(usr.getName(), usr); + resourcePoolUtilizations.put(usr.getName(), usr); } - + public void addResourcePoolTimeSeries(TimeSeriesResult timeSeriesReport) { resourcePoolTimeSeries.put(timeSeriesReport.getName(), timeSeriesReport); - } + } public void addDistributionDefinition(DistributionDefinition o) { distributionDefinitions.put(o.getName(), o); } - + public void addProcessEndCount(CountResult countResult) { processEndCounts.put(countResult.getName(), countResult); } @@ -114,44 +110,45 @@ public Document createDocument() { //Document document = DocumentHelper.createDocument(); //Element reportRoot = document.addElement( "root" ); - + // TODO: Implement or maybe skip :-) throw new RuntimeException("create xml document of simulation statistics not yet implemented"); - + // return document; } public String getScenarioName() { return scenarioName; } - + public void addBusinessFigure(String type, double sum) { - businessFigureValues.put(type, Double.valueOf(sum)); + businessFigureValues.put(type, new Double(sum)); } public void calculateResourceCosts(double unutilizedTimeCostFactor) { for (Iterator iterator = getResourcePoolUtilizations().iterator(); iterator.hasNext();) { UtilizationStatisticsResult util = (UtilizationStatisticsResult) iterator.next(); util.calculateCosts(unutilizedTimeCostFactor, simulationRunTime); - } - } + } + } public Collection getBusinessFigureTypes() { return businessFigureValues.keySet(); } public double getBusinessFigureValue(String type) { - return ((Double)businessFigureValues.get(type)).doubleValue(); + return ((Double) businessFigureValues.get(type)).doubleValue(); } /** * Convenience method after removing typo - * @deprecated + * + * @deprecated */ public double getCost() { return getCosts(); } - + /** * @return costs (resource costs and business figures of type costs) */ @@ -161,10 +158,10 @@ String type = (String) iterator.next(); if ("costs".equals(type)) { result += getBusinessFigureValue(type); - } + } } return result; - } + } /** * @return resource costs @@ -176,11 +173,11 @@ UtilizationStatisticsResult util = (UtilizationStatisticsResult) iterator.next(); result += util.getCosts(); } - + // TODO: add other costs // calculate additional "business" costs // maybe this should be calculated earlier and just be written as results here - + return result; } @@ -188,7 +185,7 @@ QueueStatisticsResult result = null; for (Iterator iterator = getResourcePoolWaitingTimes().iterator(); iterator.hasNext();) { QueueStatisticsResult stat = (QueueStatisticsResult) iterator.next(); - if (result==null || stat.getAverageWaitTime() > result.getAverageWaitTime()) { + if (result == null || stat.getAverageWaitTime() > result.getAverageWaitTime()) { result = stat; } } @@ -205,7 +202,7 @@ } return utilization / observations; } - + public int getResourceAmount() { int result = 0; for (Iterator iterator = getResourcePoolUtilizations().iterator(); iterator.hasNext();) { @@ -213,7 +210,7 @@ result += util.getPoolSize(); } return result; - } + } public DistributionDefinition getDistributionDefinition(String name) { return (DistributionDefinition) distributionDefinitions.get(name); @@ -230,7 +227,7 @@ public Collection getStateWaitingTimes() { return stateWaitingTimes.values(); } - + public ValueStatisticResult getStateWaitingTimes(String name) { return (ValueStatisticResult) stateWaitingTimes.get(name); } @@ -253,7 +250,7 @@ public Collection getDistributionDefinitions() { return distributionDefinitions.values(); - } + } public Collection getResourcePoolWaitingTimes() { return resourcePoolWaitingTimes.values(); @@ -289,11 +286,11 @@ public TimeSeriesResult getResourcePoolTimeSeriesResult(String poolName) { TimeSeriesResult result = (TimeSeriesResult) resourcePoolTimeSeries.get(poolName); - if (result==null) + if (result == null) return new TimeSeriesResult(poolName, scenarioName, new double[0], new double[0]); return result; } - + public Map getProcessEndCounts() { return processEndCounts; } @@ -304,11 +301,11 @@ public Map getProcessStartCounts() { return processStartCounts; - } + } public CountResult getProcessStartCount(String name) { return (CountResult) processStartCounts.get(name); - } + } public double getResetTime() { return resetTime; Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/BusinessFiguresTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/BusinessFiguresTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/BusinessFiguresTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,131 +1,135 @@ package org.jbpm.sim; -import java.util.Date; +import junit.framework.TestCase; import org.jbpm.graph.exe.ExecutionContext; import org.jbpm.sim.def.JbpmSimulationExperiment; -import org.jbpm.sim.def.JbpmSimulationScenario; import org.jbpm.sim.exe.ExperimentReader; import org.jbpm.sim.kpi.BusinessFigureCalculator; import org.jbpm.sim.report.ScenarioReport; -import org.jbpm.sim.report.dto.ValueStatisticResult; -import junit.framework.TestCase; - public class BusinessFiguresTest extends TestCase { - - private String testProcessXml = - "<process-definition name='test' start-distribution='startDist'>" + - " <start-state name='start'>" + - " <transition to='node1' />" + - " </start-state>" + - - " <node name='node1'>" + - " <transition to='end'>" + - " <simulation-action class='org.jbpm.sim.kpi.BusinessFigureAction'>" + - " <name>testFigure</name> " + - " </simulation-action>" + - " </transition>" + - " </node>" + + private String testProcessXml = "<process-definition name='test' start-distribution='startDist'>" + + - " <end-state name='end'/>" + + " <start-state name='start'>" + + " <transition to='node1' />" + + " </start-state>" + + - "</process-definition>" ; + " <node name='node1'>" + + " <transition to='end'>" + + " <simulation-action class='org.jbpm.sim.kpi.BusinessFigureAction'>" + + " <name>testFigure</name> " + + " </simulation-action>" + + " </transition>" + + " </node>" + + - private String experimentConfiguration = - "<experiment name='MySimulationExperiment'" + - " run-time='100'" + - " real-start-time='01.01.1970 01:00:00:002'" + - " time-unit='minute'>" + - " <scenario name ='test'>" + - " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + - " <sim-process name='test' />" + - " <business-figure name='testFigure' type='costs' " + - " automatic-calculation='none'" + // | process - start | process -end" - " handler='org.jbpm.sim.BusinessFiguresTest$BusinessFigureHandler' />" + - " </scenario>" + - "</experiment>"; - - public static class BusinessFigureHandler implements BusinessFigureCalculator{ + " <end-state name='end'/>" + + + + "</process-definition>"; + + private String experimentConfiguration = "<experiment name='MySimulationExperiment'" + + " run-time='100'" + + " real-start-time='01.01.1970 01:00:00:002'" + + " time-unit='minute'>" + + " <scenario name ='test'>" + + " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + + " <sim-process name='test' />" + + " <business-figure name='testFigure' type='costs' " + + " automatic-calculation='none'" + + // | process - start | process -end" + " handler='org.jbpm.sim.BusinessFiguresTest$BusinessFigureHandler' />" + + " </scenario>" + + "</experiment>"; + + public static class BusinessFigureHandler implements BusinessFigureCalculator { + public Number calculate(ExecutionContext executionContext) { - return Double.valueOf(10); + return new Double(10); } } - + public void testBusinessFigureConfiguredInProcess() { ExperimentReader reader = new ExperimentReader(experimentConfiguration); // inject process definition - reader.addProcessDefinition("test", testProcessXml ); - + reader.addProcessDefinition("test", testProcessXml); + JbpmSimulationExperiment experiment = reader.readExperiment(); experiment.run(); - + ScenarioReport report = experiment.getScenario("test").getScenarioReport(); - + assertEquals(1, report.getBusinessFigureTypes().size()); assertEquals("costs", report.getBusinessFigureTypes().iterator().next()); - assertEquals( - 40d, // + assertEquals(40d, // report.getBusinessFigureValue("costs"), // 0.1); } - + /** - * and now the same with the usage of the figure configured in the - * experiment, no change in the process definition required + * and now the same with the usage of the figure configured in the experiment, no change in the + * process definition required */ - - private String testProcessXml2 = - "<process-definition name='test' start-distribution='startDist'>" + - " <start-state name='start'>" + - " <transition to='node1' />" + - " </start-state>" + - - " <node name='node1'>" + - " <transition to='end' />" + - " </node>" + + private String testProcessXml2 = "<process-definition name='test' start-distribution='startDist'>" + + - " <end-state name='end'/>" + + " <start-state name='start'>" + + " <transition to='node1' />" + + " </start-state>" + + - "</process-definition>" ; + " <node name='node1'>" + + " <transition to='end' />" + + " </node>" + + - private String experimentConfiguration2 = - "<experiment name='MySimulationExperiment'" + - " run-time='100'" + - " real-start-time='01.01.1970 01:00:00:002'" + - " time-unit='minute'>" + - " <scenario name ='test'>" + - " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + + " <end-state name='end'/>" + + - " <business-figure name='testFigure' type='costs' " + - " automatic-calculation='none'" + // | process - start | process -end" - " handler='org.jbpm.sim.BusinessFiguresTest$BusinessFigureHandler' />" + + "</process-definition>"; - " <sim-process name='test'>" + - " <node-overwrite node-name='node1'>" + - " <calculate-business-figure name='testFigure' /> " + - " </node-overwrite> " + - " </sim-process>" + - - " </scenario>" + - "</experiment>"; - + private String experimentConfiguration2 = "<experiment name='MySimulationExperiment'" + + " run-time='100'" + + " real-start-time='01.01.1970 01:00:00:002'" + + " time-unit='minute'>" + + " <scenario name ='test'>" + + " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + + + + " <business-figure name='testFigure' type='costs' " + + " automatic-calculation='none'" + + // | process - start | process -end" + " handler='org.jbpm.sim.BusinessFiguresTest$BusinessFigureHandler' />" + + + + " <sim-process name='test'>" + + " <node-overwrite node-name='node1'>" + + " <calculate-business-figure name='testFigure' /> " + + " </node-overwrite> " + + " </sim-process>" + + + + " </scenario>" + + "</experiment>"; + public void testBusinessFigureConfiguredInExperiment() { ExperimentReader reader = new ExperimentReader(experimentConfiguration); // inject process definition - reader.addProcessDefinition("test", testProcessXml ); - + reader.addProcessDefinition("test", testProcessXml); + JbpmSimulationExperiment experiment = reader.readExperiment(); experiment.run(); - + ScenarioReport report = experiment.getScenario("test").getScenarioReport(); - + assertEquals(1, report.getBusinessFigureTypes().size()); assertEquals("costs", report.getBusinessFigureTypes().iterator().next()); - assertEquals( - 40d, // + assertEquals(40d, // report.getBusinessFigureValue("costs"), // 0.1); } Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/VariableSourceAndFilterTest.java =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/VariableSourceAndFilterTest.java 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/simulation/src/test/java/org/jbpm/sim/VariableSourceAndFilterTest.java 2009-05-04 09:33:28 UTC (rev 4706) @@ -4,7 +4,6 @@ import junit.framework.TestCase; -import org.jbpm.graph.def.ProcessDefinition; import org.jbpm.graph.exe.ExecutionContext; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.sim.datasource.ProcessDataFilter; @@ -14,166 +13,152 @@ import org.jbpm.sim.exe.ExperimentReader; public class VariableSourceAndFilterTest extends TestCase { - - private String testProcessXml = - "<process-definition name='test' start-distribution='startDist'>" + - " <start-state name='start'>" + - " <transition to='change order' />" + - " </start-state>" + - - " <task-node name='change order'>" + - " <task name='change order' swimlane='clerk' />" + - " <transition to='end' />" + - " </task-node>" + + private String testProcessXml = "<process-definition name='test' start-distribution='startDist'>" + + " <start-state name='start'>" + + " <transition to='change order' />" + + " </start-state>" + + " <task-node name='change order'>" + + " <task name='change order' swimlane='clerk' />" + + " <transition to='end' />" + + " </task-node>" + + " <end-state name='end'/>" + + "</process-definition>"; - " <end-state name='end'/>" + + private String experimentConfiguration = "<experiment name='MySimulationExperiment'" + + " run-time='100'" + + " real-start-time='01.01.1970 01:00:00:002'" + + " time-unit='minute'>" + + " <scenario name ='test'>" + + " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + + " <distribution name='taskDist' sample-type='real' type='constant' value='20' /> " + + " <resource-pool name='clerk' pool-size='1'/> " + + " <data-source name='orders' " + + " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableSource' /> " + + " <data-filter name='orders' " + + " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableFilter' /> " + + " <sim-process name='test'>" + + " <process-overwrite start-distribution='startDist'> " + + " <use-data-source name='orders' /> " + + " </process-overwrite> " + + " <task-overwrite task-name='change order' time-distribution='taskDist'>" + + " <use-data-filter name='orders' /> " + + " </task-overwrite> " + + " </sim-process>" + + " </scenario>" + + "</experiment>"; - "</process-definition>" ; - - - private String experimentConfiguration = - "<experiment name='MySimulationExperiment'" + - " run-time='100'" + - " real-start-time='01.01.1970 01:00:00:002'" + - " time-unit='minute'>" + - " <scenario name ='test'>" + - " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + - " <distribution name='taskDist' sample-type='real' type='constant' value='20' /> " + - - " <resource-pool name='clerk' pool-size='1'/> " + - - " <data-source name='orders' " + - " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableSource' /> " + - " <data-filter name='orders' " + - " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableFilter' /> " + - - " <sim-process name='test'>" + - " <process-overwrite start-distribution='startDist'> " + - " <use-data-source name='orders' /> " + - " </process-overwrite> " + - " <task-overwrite task-name='change order' time-distribution='taskDist'>" + - " <use-data-filter name='orders' /> " + - " </task-overwrite> " + - " </sim-process>" + - - " </scenario>" + - "</experiment>"; - -//" <event type='node-enter'><action class='org.jbpm.sim.datasource.UseDataSourceAction'> " + -//" <name>orders</name>" + -//" </action></event>" + -//" <event type='node-enter'><action class='org.jbpm.sim.datasource.UseDataFilterAction'> " + -//" <name>orders</name>" + -//" </action></event>" + - private static boolean dataSourceIsCalled = false; private static boolean dataFilterIsCalled = false; - + public static class TestProcessVariableSource implements ProcessDataSource { + public void addNextData(ExecutionContext ctx) { dataSourceIsCalled = true; ctx.getContextInstance().createVariable("test", "Hello Bernd"); } + public boolean hasNext() { return true; } + public void reset() { } } - + public static class TestProcessVariableFilter implements ProcessDataFilter { + public void changeProcessData(ExecutionContext ctx) { dataFilterIsCalled = true; String test = (String) ctx.getContextInstance().getVariable("test"); test += ", how are you?"; ctx.getContextInstance().setVariable("test", test); } + public void reset() { } } - + public void testSourceAndFilter() { ExperimentReader reader = new ExperimentReader(experimentConfiguration); // inject process definition - reader.addProcessDefinition("test", testProcessXml ); - + reader.addProcessDefinition("test", testProcessXml); + JbpmSimulationExperiment experiment = reader.readExperiment(); experiment.setRememberEndedProcessInstances(true); experiment.run(); - + assertTrue(dataSourceIsCalled); assertTrue(dataFilterIsCalled); JbpmSimulationScenario scenario = experiment.getScenario("test"); ProcessInstance pi = (ProcessInstance) scenario.getEndedProcessInstances().iterator().next(); - + assertEquals("Hello Bernd, how are you?", pi.getContextInstance().getVariable("test")); - + // simulation runs till the end - assertEquals(100, scenario.getScenarioReport().getSimulationRunTime(), 0.001); - } - - private String experimentConfiguration2 = - "<experiment name='MySimulationExperiment'" + - " run-time='100'" + - " real-start-time='01.01.1970 01:00:00:002'" + - " time-unit='minute'>" + - " <scenario name ='test'>" + - " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + - " <distribution name='taskDist' sample-type='real' type='constant' value='20' /> " + + assertEquals(100, scenario.getScenarioReport().getSimulationRunTime(), 0.001); + } - " <resource-pool name='clerk' pool-size='1'/> " + + private String experimentConfiguration2 = "<experiment name='MySimulationExperiment'" + + " run-time='100'" + + " real-start-time='01.01.1970 01:00:00:002'" + + " time-unit='minute'>" + + " <scenario name ='test'>" + + " <distribution name='startDist' sample-type='real' type='constant' value='20' /> " + + " <distribution name='taskDist' sample-type='real' type='constant' value='20' /> " + + " <resource-pool name='clerk' pool-size='1'/> " + + " <data-source name='orders' " + + " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableSourceExhausting' /> " + + " <sim-process name='test'>" + + " <process-overwrite start-distribution='startDist'> " + + " <use-data-source name='orders' /> " + + " </process-overwrite> " + + " <task-overwrite task-name='change order' time-distribution='taskDist' />" + + " </sim-process>" + + " </scenario>" + + "</experiment>"; - " <data-source name='orders' " + - " handler='org.jbpm.sim.VariableSourceAndFilterTest$TestProcessVariableSourceExhausting' /> " + - - " <sim-process name='test'>" + - " <process-overwrite start-distribution='startDist'> " + - " <use-data-source name='orders' /> " + - " </process-overwrite> " + - " <task-overwrite task-name='change order' time-distribution='taskDist' />" + - " </sim-process>" + - - " </scenario>" + - "</experiment>"; - private static int calledCount = 0; - + public static class TestProcessVariableSourceExhausting implements ProcessDataSource { - public void addNextData(ExecutionContext ctx) { + + public void addNextData(ExecutionContext ctx) { calledCount++; - ctx.getContextInstance().createVariable("test", Integer.valueOf(calledCount)); + ctx.getContextInstance().createVariable("test", new Integer(calledCount)); } + public boolean hasNext() { - return (calledCount<3); + return (calledCount < 3); } + public void reset() { } } - + /** - * use a data source which provides data only three times, the simulation should be - * ended after the third query, at this time two processes are ended + * use a data source which provides data only three times, the simulation should be ended after + * the third query, at this time two processes are ended */ - public void testSimulationStopIfSourceIsExhausted() { ExperimentReader reader = new ExperimentReader(experimentConfiguration2); // inject process definition - reader.addProcessDefinition("test", testProcessXml ); - + reader.addProcessDefinition("test", testProcessXml); + JbpmSimulationExperiment experiment = reader.readExperiment(); experiment.setRememberEndedProcessInstances(true); experiment.run(); - + JbpmSimulationScenario scenario = experiment.getScenario("test"); List processes = scenario.getEndedProcessInstances(); - + assertEquals(3, calledCount); assertEquals(2, processes.size()); - - assertEquals(Integer.valueOf(1), ((ProcessInstance)processes.get(0)).getContextInstance().getVariable("test")); - assertEquals(Integer.valueOf(2), ((ProcessInstance)processes.get(1)).getContextInstance().getVariable("test")); + assertEquals(new Integer(1), ((ProcessInstance) processes.get(0)).getContextInstance() + .getVariable("test")); + assertEquals(new Integer(2), ((ProcessInstance) processes.get(1)).getContextInstance() + .getVariable("test")); + // after two processes the simulation should end, this is 60 time units assertEquals(60, scenario.getScenarioReport().getSimulationRunTime(), 0.001); } Deleted: jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.classpath =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.classpath 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.classpath 2009-05-04 09:33:28 UTC (rev 4706) @@ -1,6 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<classpath> - <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> - <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> - <classpathentry kind="output" path="target/classes"/> -</classpath> Modified: jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.project =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.project 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/modules/userguide/.project 2009-05-04 09:33:28 UTC (rev 4706) @@ -6,18 +6,12 @@ </projects> <buildSpec> <buildCommand> - <name>org.eclipse.jdt.core.javabuilder</name> - <arguments> - </arguments> - </buildCommand> - <buildCommand> <name>org.maven.ide.eclipse.maven2Builder</name> <arguments> </arguments> </buildCommand> </buildSpec> <natures> - <nature>org.eclipse.jdt.core.javanature</nature> <nature>org.maven.ide.eclipse.maven2Nature</nature> </natures> </projectDescription> Modified: jbpm3/branches/jbpm-3.2.5.SP/pom.xml =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/pom.xml 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/pom.xml 2009-05-04 09:33:28 UTC (rev 4706) @@ -47,7 +47,6 @@ <apache.cactus.version>1.8.0</apache.cactus.version> <apache.jackrabbit.version>1.4.5</apache.jackrabbit.version> <birt.version>2.2.2</birt.version> - <bpm.spec.version>1.0.0-Alpha1</bpm.spec.version> <bsh.version>1.3.0</bsh.version> <commons.fileupload.version>1.2.1</commons.fileupload.version> <commons.io.version>1.4</commons.io.version> @@ -57,32 +56,23 @@ <drools.version>4.0.7</drools.version> <dumbster.version>1.6</dumbster.version> <hibernate.version>3.2.6.ga</hibernate.version> - <hibernate.validator.version>3.0.0.ga</hibernate.validator.version> <izpack.version>4.1.0</izpack.version> <jasper.reports.version>3.0.0</jasper.reports.version> - <javax.ejb.version>3.0</javax.ejb.version> <javax.el.version>1.2</javax.el.version> <javax.faces.version>1.2_03</javax.faces.version> <javax.jcr.version>1.0.1</javax.jcr.version> - <javax.jms.version>1.1</javax.jms.version> - <javax.jws.version>1.0-MR1</javax.jws.version> <javax.mail.version>1.4</javax.mail.version> <javax.servlet.version>2.5</javax.servlet.version> - <javax.persistence.version>1.0</javax.persistence.version> - <javax.jaxb.version>2.1</javax.jaxb.version> <jaxen.version>1.1.1</jaxen.version> + <jboss.j2ee.version>4.0.2</jboss.j2ee.version> <jbpm.designer.version>3.1.7</jbpm.designer.version> - <jbpm.jsf-console.version>3.2.6.SP2</jbpm.jsf-console.version> - <jboss.client.version>4.2.2.GA</jboss.client.version> + <jbpm.jsf-console.version>3.2.6.SP3</jbpm.jsf-console.version> + <jboss.client.version>4.0.5.GA</jboss.client.version> <jboss.gravel.version>1.0.0.GA</jboss.gravel.version> - <jboss.seam.version>2.0.2.GA</jboss.seam.version> <jdocbook.version>2.1.2</jdocbook.version> <junit.version>3.8.1</junit.version> - <oscache.version>2.4</oscache.version> - <poi.version>3.0.2-FINAL</poi.version> <richfaces.ui.version>3.2.1.GA</richfaces.ui.version> <report-server.version>1.0.0.Beta1</report-server.version> - <slf4j.version>1.5.5</slf4j.version> <sun.facelets.version>1.1.14</sun.facelets.version> <!-- Database Driver Versions --> @@ -124,13 +114,6 @@ <type>war</type> </dependency> - <!-- BPM Spec Dependencies--> - <dependency> - <groupId>org.jboss.bpm</groupId> - <artifactId>bpm-spec-api</artifactId> - <version>${bpm.spec.version}</version> - </dependency> - <!-- Thirdparty Dependencies --> <dependency> <groupId>bsh</groupId> @@ -138,12 +121,6 @@ <version>${bsh.version}</version> </dependency> <dependency> - <groupId>org.eclipse.birt</groupId> - <artifactId>report-engine</artifactId> - <type>zip</type> - <version>${birt.version}</version> - </dependency> - <dependency> <groupId>com.sun.facelets</groupId> <artifactId>jsf-facelets</artifactId> <version>${sun.facelets.version}</version> @@ -194,11 +171,6 @@ <version>${jaxen.version}</version> </dependency> <dependency> - <groupId>javax.ejb</groupId> - <artifactId>ejb-api</artifactId> - <version>${javax.ejb.version}</version> - </dependency> - <dependency> <groupId>javax.el</groupId> <artifactId>el-api</artifactId> <version>${javax.el.version}</version> @@ -219,41 +191,21 @@ <version>${javax.jcr.version}</version> </dependency> <dependency> - <groupId>javax.jms</groupId> - <artifactId>jms</artifactId> - <version>${javax.jms.version}</version> - </dependency> - <dependency> - <groupId>javax.jws</groupId> - <artifactId>jsr181-api</artifactId> - <version>${javax.jws.version}</version> - </dependency> - <dependency> <groupId>javax.mail</groupId> <artifactId>mail</artifactId> <version>${javax.mail.version}</version> </dependency> <dependency> - <groupId>javax.persistence</groupId> - <artifactId>persistence-api</artifactId> - <version>${javax.persistence.version}</version> - </dependency> - <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>${javax.servlet.version}</version> </dependency> <dependency> - <groupId>javax.xml.bind</groupId> - <artifactId>jaxb-api</artifactId> - <version>${javax.jaxb.version}</version> + <groupId>jboss</groupId> + <artifactId>jboss-j2ee</artifactId> + <version>${jboss.j2ee.version}</version> </dependency> <dependency> - <groupId>opensymphony</groupId> - <artifactId>oscache</artifactId> - <version>${oscache.version}</version> - </dependency> - <dependency> <groupId>org.apache.ant</groupId> <artifactId>ant</artifactId> <version>${apache.ant.version}</version> @@ -289,11 +241,6 @@ <version>${hibernate.version}</version> </dependency> <dependency> - <groupId>org.hibernate</groupId> - <artifactId>hibernate-validator</artifactId> - <version>${hibernate.validator.version}</version> - </dependency> - <dependency> <groupId>org.jboss.client</groupId> <artifactId>jbossall-client</artifactId> <version>${jboss.client.version}</version> @@ -304,74 +251,11 @@ <version>${jboss.gravel.version}</version> </dependency> <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam</artifactId> - <version>${jboss.seam.version}</version> - <type>ejb</type> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-debug</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-ioc</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-mail</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-pdf</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-remoting</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> - <groupId>org.jboss.seam</groupId> - <artifactId>jboss-seam-ui</artifactId> - <version>${jboss.seam.version}</version> - </dependency> - <dependency> <groupId>org.richfaces.ui</groupId> <artifactId>richfaces-ui</artifactId> <version>${richfaces.ui.version}</version> </dependency> <dependency> - <groupId>org.slf4j</groupId> - <artifactId>slf4j-api</artifactId> - <version>${slf4j.version}</version> - </dependency> - <dependency> - <groupId>org.slf4j</groupId> - <artifactId>slf4j-log4j12</artifactId> - <version>${slf4j.version}</version> - </dependency> - <dependency> - <groupId>poi</groupId> - <artifactId>poi</artifactId> - <version>${poi.version}</version> - </dependency> - <dependency> - <groupId>poi</groupId> - <artifactId>poi-contrib</artifactId> - <version>${poi.version}</version> - </dependency> - <dependency> - <groupId>poi</groupId> - <artifactId>poi-scratchpad</artifactId> - <version>${poi.version}</version> - </dependency> - - <!-- Database Driver Versions --> - <dependency> <groupId>hsqldb</groupId> <artifactId>hsqldb</artifactId> <version>${hsqldb.version}</version> @@ -386,6 +270,8 @@ <artifactId>postgresql</artifactId> <version>${postgresql.version}</version> </dependency> + + <!-- Database Driver Versions --> </dependencies> </dependencyManagement> @@ -416,9 +302,10 @@ </pluginManagement> <plugins> <plugin> - <artifactId>maven-surefire-plugin</artifactId> + <artifactId>maven-compiler-plugin</artifactId> <configuration> - <testFailureIgnore>false</testFailureIgnore> + <source>1.4</source> + <target>1.4</target> </configuration> </plugin> </plugins> Modified: jbpm3/branches/jbpm-3.2.5.SP/profiles.xml.example =================================================================== --- jbpm3/branches/jbpm-3.2.5.SP/profiles.xml.example 2009-05-04 06:24:34 UTC (rev 4705) +++ jbpm3/branches/jbpm-3.2.5.SP/profiles.xml.example 2009-05-04 09:33:28 UTC (rev 4706) @@ -11,9 +11,9 @@ </property> </activation> <properties> - <jboss422.home>/home/tdiesler/svn/jbossas/tags/JBoss_4_2_2_GA/build/output/jboss-4.2.2.GA</jboss422.home> - <jboss423.home>/home/tdiesler/svn/jbossas/tags/JBoss_4_2_3_GA/build/output/jboss-4.2.3.GA</jboss423.home> - <jboss500.home>/home/tdiesler/svn/jbossas/tags/JBoss_5_0_0_GA/build/output/jboss-5.0.0.GA</jboss500.home> + <jboss405.home>${user.home}/Downloads/jboss/jboss-4.0.5.GA</jboss405.home> + <jboss423.home>${user.home}/Downloads/jboss/jboss-4.2.3.GA</jboss423.home> + <jboss501.home>${user.home}/Downloads/jboss/jboss-5.0.1.GA</jboss501.home> <!-- <jdbc.mysql.server>localhost</jdbc.mysql.server>