public virtual void testConcurrentVariableRemoval() { Deployment(ESS.FW.Bpm.Model.Bpmn.Bpmn.CreateExecutableProcess("test").StartEvent().UserTask().EndEvent().Done()); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final byte[] byteVar = "asd".GetBytes(); byte[] byteVar = "asd".GetBytes(); string pid = runtimeService.StartProcessInstanceByKey("test", ESS.FW.Bpm.Engine.Variable.Variables.CreateVariables().PutValue("byteVar", byteVar)).Id; // start a controlled Fetch and Update variable command asyncThread = ExecuteControllableCommand <object>(new FetchAndUpdateVariableCmd(pid, "byteVar", "bsd".GetBytes())); asyncThread.WaitForSync(); // now Delete the process instance, deleting the variable and its byte array entity runtimeService.DeleteProcessInstance(pid, null); // make the second thread continue // => this will a flush the FetchVariableCmd Context. // if the flush performs an update to the variable, it will Assert.Fail with an OLE asyncThread.ReportInterrupts(); asyncThread.WaitUntilDone(); System.Exception exception = asyncThread.Exception; Assert.NotNull(exception); Assert.True(exception is OptimisticLockingException); }
public virtual void testTimeoutOnUpdate() { createJobEntity(); thread1 = ExecuteControllableCommand(new UpdateJobCommand("p1")); // wait for thread 1 to perform UPDATE thread1.WaitForSync(); thread2 = ExecuteControllableCommand(new UpdateJobCommand("p2")); // wait for thread 2 to perform UPDATE thread2.WaitForSync(); // perform FLUSH for thread 1 (but no commit of transaction) thread1.MakeContinue(); // wait for thread 1 to perform FLUSH thread1.WaitForSync(); // perform FLUSH for thread 2 thread2.MakeContinue(); // wait for thread 2 to cancel FLUSH because of timeout thread2.ReportInterrupts(); thread2.WaitForSync(TEST_TIMEOUT_IN_MILLIS); Assert.NotNull(thread2.Exception, "expected timeout exception"); }
public virtual void testConcurrentTreeCompactionAndMessageCorrelation() { runtimeService.StartProcessInstanceByKey("process"); IList <ITask> tasks = taskService.CreateTaskQuery().ToList(); // trigger tree compaction and wait before flush ThreadControl taskCompletionThread = ExecuteControllableCommand(new ControllableCompleteTaskCommand(tasks)); taskCompletionThread.ReportInterrupts(); // stop task completion right before flush taskCompletionThread.WaitForSync(); // perform message correlation to non-interrupting boundary event // (i.E. adds another concurrent execution to the scope execution) runtimeService.CorrelateMessage("Message"); // flush task completion and tree compaction taskCompletionThread.WaitUntilDone(); // then it should not have succeeded System.Exception exception = taskCompletionThread.Exception; Assert.NotNull(exception); Assert.True(exception is OptimisticLockingException); }
public virtual void testConcurrentMessageCorrelationTwiceAndTreeCompaction() { runtimeService.StartProcessInstanceByKey("process"); // trigger non-interrupting boundary event 1 that ends in a none end event immediately runtimeService.CorrelateMessage("Message2"); // trigger non-interrupting boundary event 2 and wait before flush ThreadControl correlateThread = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message1", false)); correlateThread.ReportInterrupts(); // stop correlation right before the flush correlateThread.WaitForSync(); correlateThread.MakeContinueAndWaitForSync(); // trigger tree compaction IList <ITask> tasks = taskService.CreateTaskQuery().ToList(); foreach (ITask task in tasks) { taskService.Complete(task.Id); } // flush correlation correlateThread.WaitUntilDone(); // the correlation should not have succeeded System.Exception exception = correlateThread.Exception; Assert.NotNull(exception); Assert.True(exception is OptimisticLockingException); }
public virtual void testEventSubprocess() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("incoming", false)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("incoming", false)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // both threads correlate thread1.MakeContinue(); thread2.MakeContinue(); thread1.WaitForSync(); thread2.WaitForSync(); // the first thread ends its transaction thread1.WaitUntilDone(); Assert.IsNull(thread1.Exception); // the second thread ends its transaction and fails with optimistic locking exception thread2.WaitUntilDone(); Assert.True(thread2.Exception != null); Assert.True(thread2.Exception is OptimisticLockingException); }
public virtual void testConcurrentExclusiveCorrelation() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", true)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", true)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // thread one correlates and acquires the exclusive lock thread1.MakeContinue(); thread1.WaitForSync(); // the service task was executed once Assert.AreEqual(1, InvocationLogListener.Invocations); // thread two attempts to acquire the exclusive lock but can't since thread 1 hasn't released it yet thread2.MakeContinue(); Thread.Sleep(2000); // let the first thread ends its transaction thread1.MakeContinue(); Assert.IsNull(thread1.Exception); // thread 2 can't continue because the event subscription it tried to lock was deleted thread2.WaitForSync(); Assert.True(thread2.Exception != null); Assert.True(thread2.Exception is ProcessEngineException); AssertTextPresent("does not have a subscription to a message event with name 'Message'", thread2.Exception.Message); // the first thread ended successfully without an exception thread1.Join(); Assert.IsNull(thread1.Exception); // the follow-up task was reached ITask afterMessageTask = taskService.CreateTaskQuery().First(); Assert.AreEqual(afterMessageTask.TaskDefinitionKey, "afterMessageUserTask"); // the service task was not executed a second time Assert.AreEqual(1, InvocationLogListener.Invocations); }
public virtual void FAILING_testConcurrentMixedCorrelationCase2() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel (one exclusive, one non-exclusive) ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", false)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", true)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // thread one correlates and acquires no lock thread1.MakeContinue(); thread1.WaitForSync(); // thread two acquires a lock and succeeds because thread one hasn't acquired one thread2.MakeContinue(); thread2.WaitForSync(); // the service task was executed twice Assert.AreEqual(2, InvocationLogListener.Invocations); // thread one ends its transaction and blocks on flush when it attempts to Delete the event subscription thread1.MakeContinue(); Thread.Sleep(5000); Assert.IsNull(thread1.Exception); Assert.AreEqual(0, taskService.CreateTaskQuery().Count()); // thread 2 flushes successfully and releases the lock thread2.WaitUntilDone(); Assert.IsNull(thread2.Exception); ITask afterMessageTask = taskService.CreateTaskQuery().First(); Assert.NotNull(afterMessageTask); Assert.AreEqual(afterMessageTask.TaskDefinitionKey, "afterMessageUserTask"); // thread 1 flush fails with optimistic locking thread1.Join(); Assert.True(thread1.Exception != null); Assert.True(thread1.Exception is OptimisticLockingException); }
public virtual void testConcurrentExclusiveCorrelationToDifferentExecutions() { InvocationLogListener.reset(); // given a process instance IProcessInstance instance1 = runtimeService.StartProcessInstanceByKey("testProcess"); IProcessInstance instance2 = runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel to each of the two instances ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", instance1.Id, true)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", instance2.Id, true)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // thread one correlates and acquires the exclusive lock on the event subscription of instance1 thread1.MakeContinue(); thread1.WaitForSync(); // the service task was executed once Assert.AreEqual(1, InvocationLogListener.Invocations); // thread two correlates and acquires the exclusive lock on the event subscription of instance2 // depending on the database and locking used, this may block thread2 thread2.MakeContinue(); // thread 1 completes successfully thread1.WaitUntilDone(); Assert.IsNull(thread1.Exception); // thread2 should be able to continue at least after thread1 has finished and released its lock thread2.WaitForSync(); // the service task was executed the second time Assert.AreEqual(2, InvocationLogListener.Invocations); // thread 2 completes successfully thread2.WaitUntilDone(); Assert.IsNull(thread2.Exception); // the follow-up task was reached in both instances Assert.AreEqual(2, taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "afterMessageUserTask").Count()); }
public virtual void testConcurrentEndExecutionListener() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); IList <IExecution> tasks = runtimeService.CreateExecutionQuery() /*.MessageEventSubscriptionName("Message")*/.ToList(); // two tasks waiting for the message Assert.AreEqual(2, tasks.Count); // start first thread and wait in the second execution end listener ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageEventReceivedCommand(tasks[0].Id, "Message", true)); thread1.ReportInterrupts(); thread1.WaitForSync(); // the counting execution listener was executed on task 1 Assert.AreEqual(1, InvocationLogListener.Invocations); // start second thread and complete the task ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageEventReceivedCommand(tasks[1].Id, "Message", false)); thread2.WaitForSync(); thread2.WaitUntilDone(); // the counting execution listener was executed on task 1 and 2 Assert.AreEqual(2, InvocationLogListener.Invocations); // continue with thread 1 thread1.MakeContinueAndWaitForSync(); // the counting execution listener was not executed again Assert.AreEqual(2, InvocationLogListener.Invocations); // try to complete thread 1 thread1.WaitUntilDone(); // thread 1 was rolled back with an optimistic locking exception System.Exception exception = thread1.Exception; Assert.NotNull(exception); Assert.True(exception is OptimisticLockingException); // the execution listener was not executed again Assert.AreEqual(2, InvocationLogListener.Invocations); }
public virtual void testConcurrentMixedCorrelation() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel (one exclusive, one non-exclusive) ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", true)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", false)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // thread one correlates and acquires the exclusive lock thread1.MakeContinue(); thread1.WaitForSync(); // thread two correlates since it does not need a pessimistic lock thread2.MakeContinue(); thread2.WaitForSync(); // the service task was executed twice Assert.AreEqual(2, InvocationLogListener.Invocations); // the first thread ends its transaction and releases the lock; the event subscription is now gone thread1.WaitUntilDone(); Assert.IsNull(thread1.Exception); ITask afterMessageTask = taskService.CreateTaskQuery().First(); Assert.AreEqual(afterMessageTask.TaskDefinitionKey, "afterMessageUserTask"); // thread two attempts to end its transaction and fails with optimistic locking thread2.MakeContinue(); thread2.WaitForSync(); Assert.True(thread2.Exception != null); Assert.True(thread2.Exception is OptimisticLockingException); }
public virtual void testConcurrentCorrelationFailsWithOptimisticLockingException() { InvocationLogListener.reset(); // given a process instance runtimeService.StartProcessInstanceByKey("testProcess"); // and two threads correlating in parallel ThreadControl thread1 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", false)); thread1.ReportInterrupts(); ThreadControl thread2 = ExecuteControllableCommand(new ControllableMessageCorrelationCommand("Message", false)); thread2.ReportInterrupts(); // both threads open a transaction and wait before correlating the message thread1.WaitForSync(); thread2.WaitForSync(); // both threads correlate thread1.MakeContinue(); thread2.MakeContinue(); thread1.WaitForSync(); thread2.WaitForSync(); // the service task was executed twice Assert.AreEqual(2, InvocationLogListener.Invocations); // the first thread ends its transcation thread1.WaitUntilDone(); Assert.IsNull(thread1.Exception); ITask afterMessageTask = taskService.CreateTaskQuery().First(); Assert.AreEqual(afterMessageTask.TaskDefinitionKey, "afterMessageUserTask"); // the second thread ends its transaction and fails with optimistic locking exception thread2.WaitUntilDone(); Assert.True(thread2.Exception != null); Assert.True(thread2.Exception is OptimisticLockingException); }