public function apply(WorkflowHistory $history)
{
$item = $this->getHistoryItem($history, $this->getAttribute('scheduledEventId'));
$item->setTimeEnded($this->timestamp);
$item->setResult($this->getAttribute('result'));
$item->setState(HistoryItemState::COMPLETED());
$history->add($item);
}
public function testCounts()
{
$history = new WorkflowHistory();
$history->add($this->createHistoryItem('test-activity', '1', HistoryItemState::COMPLETED(), 'alpha'));
$history->add($this->createHistoryItem('test-activity', '1', HistoryItemState::COMPLETED(), 'bravo'));
$history->add($this->createHistoryItem('test-activity', '2', HistoryItemState::COMPLETED(), 'charlie'));
$history->add($this->createHistoryItem('test-activity', '1', HistoryItemState::SCHEDULED(), 'delta'));
$history->add($this->createHistoryItem('other-activity', '1', HistoryItemState::COMPLETED(), 'echo'));
$history->add($this->createHistoryItem('other-activity', '1', HistoryItemState::RUNNING(), 'foxtrot'));
$inspector = new HistoryInspector($history);
$schema_test = TaskSchema::fromKey('test-activity/1');
$schema_other = TaskSchema::fromKey('other-activity/1');
$this->assertEquals(0, $inspector->countTask($schema_test, HistoryItemState::RUNNING()));
$this->assertEquals(0, $inspector->countTask($schema_test, HistoryItemState::FAILED()));
$this->assertEquals(2, $inspector->countTask($schema_test, HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countTask($schema_test, HistoryItemState::SCHEDULED()));
$this->assertEquals(1, $inspector->countTask($schema_other, HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countTask($schema_other, HistoryItemState::RUNNING()));
$this->assertEquals(0, $inspector->countTask($schema_other, HistoryItemState::SCHEDULED()));
$this->assertEquals(0, $inspector->countTask($schema_other, HistoryItemState::FAILED()));
$this->assertEquals(1, $inspector->countControl('alpha', HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countControl('bravo', HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countControl('charlie', HistoryItemState::COMPLETED()));
$this->assertEquals(0, $inspector->countControl('delta', HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countControl('echo', HistoryItemState::COMPLETED()));
$this->assertEquals(0, $inspector->countControl('foxtrot', HistoryItemState::COMPLETED()));
$this->assertTrue($inspector->haveOpenActivities());
$alpha = new TaskSchema();
$alpha->setActivityName('test-activity')->setActivityVersion('1')->setControl('alpha');
$this->assertEquals(2, $inspector->countTask($alpha, HistoryItemState::COMPLETED()));
$this->assertEquals(1, $inspector->countTask($alpha, HistoryItemState::SCHEDULED()));
$omega = new TaskSchema();
$omega->setActivityName('test-activity')->setActivityVersion('10');
$this->assertEquals(0, $inspector->countTask($omega, HistoryItemState::COMPLETED()));
$this->assertTrue($inspector->hasTaskBeenScheduled($alpha));
$this->assertFalse($inspector->hasTaskBeenScheduled($omega));
}
/**
* Process the decision event, generating a decision response (included in the DecisionEvent)
*
* @param DecisionEvent $event
*/
public function processDecisionEvent(DecisionEvent $event)
{
$history = $event->getHistory();
$decision = $event->getDecision();
$tasks = $this->getWorkflow()->getTasks();
// Create a memory pool jailed to this execution
$memory_pool = $this->getWorkflow()->getJailMemoryPool() ? JailedMemoryPool::jail($this->getMemoryPool(), ':' . $event->getExecutionId()) : $this->getMemoryPool();
// Check if we need to execute any task events
/** @var WorkflowHistoryItem $history_item */
foreach ($history as $history_item) {
$id = $history_item->getEventId();
if ($history_item->getState() == HistoryItemState::COMPLETED()) {
if ($memory_pool->get('history:' . $id . ':completed') === null) {
$this->runTaskDecider($history_item, $decision, $memory_pool);
$memory_pool->set('history:' . $id . ':completed', 1);
}
}
}
// Check if we need to fail
if ($this->getFailOnActivityFailure() && $history->hasActivityFailure() || $history->hasWorkflowFailed()) {
$decision->setWorkflowResult(WorkflowResult::FAIL());
$decision->setReason(implode(", ", $history->getErrorMessages()));
return;
}
// Check if we need to schedule
$parser = new InputParser($history, $memory_pool);
$scheduler = new Scheduler($history, $memory_pool);
foreach ($tasks as $task) {
if ($scheduler->canScheduleTask($task)) {
$decision->scheduledTask($parser->compileTaskInput($task));
}
}
// Check if we need to complete
if (count($decision->getScheduledTasks()) == 0 && !$scheduler->haveOpenActivities()) {
$decision->setWorkflowResult(WorkflowResult::COMPLETE());
}
}
/**
* Check if this history item completed successfully
*
* @return bool
*/
public function isSuccess()
{
return $this->state == HistoryItemState::COMPLETED();
}
public function testSampleWorkflow()
{
Conf::init(__DIR__ . '/../../../../config/');
$memory_pool = new RedisMemoryPool('decider-tests-' . time(), 60, Conf::get('redis'));
$decider = new Decider();
$decider->setWorkflow(new YamlWorkflow(__DIR__ . '/../Resources/TestSchema.yml'));
$decider->setMemoryPool($memory_pool)->setAuxPayload('payload');
$this->assertTrue($decider->getWorkflow()->getJailMemoryPool());
$execution_id = 'test-execution';
// Workflow started -
$event1 = new DecisionEvent();
$event1->setExecutionId($execution_id);
$decider->processDecisionEvent($event1);
$this->assertCount(1, $event1->getDecision()->getScheduledTasks());
$this->assertEquals(WorkflowResult::COMMAND(), $event1->getDecision()->getWorkflowResult());
$task = $event1->getDecision()->getScheduledTasks()[0];
$this->assertEquals('alpha', $task->getControl());
$this->assertEquals('alpha', $task->getActivityName());
$this->assertEquals('1', $task->getActivityVersion());
// Task 1 complete -
$alpha = new WorkflowHistoryItem('1');
$alpha->setActivityName('alpha')->setActivityVersion('1');
$alpha->setTimeScheduled(new \DateTime('2014-10-10 10:01:00'));
$alpha->setTimeStarted(new \DateTime('2014-10-10 10:00:00'));
$alpha->setTimeEnded(new \DateTime('2014-10-10 10:04:00'));
$alpha->setState(HistoryItemState::COMPLETED());
$alpha->setControl('alpha')->setInput('alpha')->setResult("Hello World");
$event2 = new DecisionEvent();
$event2->setExecutionId($execution_id);
$event2->getHistory()->add($alpha);
$decider->processDecisionEvent($event2);
$this->assertCount(2, $event2->getDecision()->getScheduledTasks());
$this->assertEquals(WorkflowResult::COMMAND(), $event2->getDecision()->getWorkflowResult());
$task = $event2->getDecision()->getScheduledTasks()[0];
$this->assertEquals('bravo', $task->getControl());
// Task 2 complete -
$bravo = new WorkflowHistoryItem('2');
$bravo->setActivityName('bravo')->setActivityVersion('1');
$bravo->setTimeScheduled(new \DateTime('2014-11-10 10:01:00'));
$bravo->setTimeStarted(new \DateTime('2014-11-10 10:00:00'));
$bravo->setTimeEnded(new \DateTime('2014-11-10 10:04:00'));
$bravo->setState(HistoryItemState::COMPLETED());
$bravo->setControl('bravo')->setInput('bravo')->setResult("Hello World");
$memory_pool->set(":test-execution:alpha", 1);
$memory_pool->set(":test-execution:bravo", 2);
$event3 = new DecisionEvent();
$event3->setExecutionId($execution_id);
$event3->getHistory()->add($alpha);
$event3->getHistory()->add($bravo);
$decider->processDecisionEvent($event3);
$this->assertCount(1, $event3->getDecision()->getScheduledTasks());
$this->assertEquals(WorkflowResult::COMMAND(), $event3->getDecision()->getWorkflowResult());
$task = $event3->getDecision()->getScheduledTasks()[0];
$this->assertEquals('charlie', $task->getControl());
// Task 3 complete -
$charlie = new WorkflowHistoryItem('3');
$charlie->setActivityName('charlie')->setActivityVersion('1');
$charlie->setTimeScheduled(new \DateTime('2014-11-10 10:01:00'));
$charlie->setTimeStarted(new \DateTime('2014-11-10 10:00:00'));
$charlie->setTimeEnded(new \DateTime('2014-11-10 10:04:00'));
$charlie->setState(HistoryItemState::COMPLETED());
$charlie->setControl('charlie')->setInput('charlie')->setResult("Hello World");
$event4 = new DecisionEvent();
$event4->setExecutionId($execution_id);
$event4->getHistory()->add($alpha);
$event4->getHistory()->add($bravo);
$event4->getHistory()->add($charlie);
$decider->processDecisionEvent($event4);
$this->assertCount(0, $event4->getDecision()->getScheduledTasks());
$this->assertEquals(WorkflowResult::COMPLETE(), $event4->getDecision()->getWorkflowResult());
}
/**
* Check if we meet all reason requirements
*
* @param array $requirements
* @return bool
*/
protected function meetsControlRequirements(array $requirements)
{
foreach ($requirements as $control => $count) {
if ($this->history_inspector->countControl($control, HistoryItemState::COMPLETED()) != $count) {
return false;
}
}
return true;
}
