public function __construct($name, $priority, VirtualExecution $execution = NULL, $documentation = NULL) { $this->name = (string) $name; $this->priority = (int) $priority; $this->executionId = $execution === NULL ? NULL : $execution->getId(); $this->documentation = $documentation === NULL ? NULL : (string) $documentation; }
public function __construct($signal, UUID $executionId = NULL, array $variables = [], VirtualExecution $sourceExecution = NULL) { $this->signal = (string) $signal; $this->variables = serialize($variables); $this->executionId = $executionId; $this->sourceExecutionId = $sourceExecution === NULL ? NULL : $sourceExecution->getId(); }
/** * {@inheritdoc} */ public function interrupt(VirtualExecution $execution, array $transitions = NULL) { foreach ($execution->findChildExecutions() as $sub) { $sub->terminate(false); } parent::interrupt($execution, $transitions); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $engine = $execution->getEngine(); $name = $this->getStringValue($this->name, $execution->getExpressionContext()); $execution->getEngine()->debug('Executing manual task "{task}"', ['task' => $name]); $engine->notify(new TaskExecutedEvent($name, new DelegateExecution($execution), $engine)); $this->leave($execution); }
/** * {@inheritdoc} */ public function processSignal(VirtualExecution $execution, $signal, array $variables = [], array $delegation = []) { $engine = $execution->getEngine(); $engine->notify(new ActivityCompletedEvent($execution->getNode()->getId(), $execution, $engine)); $node = $execution->getProcessModel()->findNode($delegation['nodeId']); $engine->notify(new ActivityStartedEvent($node->getId(), $execution, $engine)); $this->delegateSignal($execution, $signal, $variables, $delegation); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $engine = $execution->getEngine(); $name = $this->getStringValue($this->name, $execution->getExpressionContext()); $engine->debug('{execution} reached checkpoint "{checkpoint}" ({node})', ['execution' => (string) $execution, 'checkpoint' => $this->name, 'node' => $execution->getNode()->getId()]); $engine->notify(new CheckpointReachedEvent($name, new DelegateExecution($execution), $engine)); $this->leave($execution); }
/** * Create a new persisted event subscription. * * @param string $name Name of the subscription type: "signal", "message", etc. * @param VirtualExecution $execution Target execution. * @param string $activityId ID of the activity that created the event subscription. * @param Node $node Target node to receive the delegated signal or NULL in order to use the activity node. * @param boolean $boundaryEvent Is this a subscription for a boundary event? */ public function __construct($name, VirtualExecution $execution, $activityId, Node $node = NULL, $boundaryEvent = false) { $this->name = (string) $name; $this->executionId = $execution->getId(); $this->activityId = (string) $activityId; $this->nodeId = $node === NULL ? NULL : (string) $node->getId(); $this->boundaryEvent = $boundaryEvent ? true : false; }
public function setParentExecution(VirtualExecution $parent = NULL) { if ($parent !== NULL) { $this->parentExecution = $parent; $parent->registerChildExecution($this); } $this->markModified(); }
/** * {@inheritdoc} */ public function createEventSubscriptions(VirtualExecution $execution, $activityId, Node $node = NULL) { $date = $this->getDateValue($this->date, $execution->getExpressionContext()); if (!$date instanceof \DateTimeInterface) { throw new \RuntimeException(sprintf('Expecting DateTimeInterface, given %s', is_object($date) ? get_class($date) : gettype($date))); } $execution->getEngine()->executeCommand(new CreateTimerSubscriptionCommand($date, $execution, $activityId, $node === NULL ? $execution->getNode() : $node)); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $engine = $execution->getEngine(); $typeName = $this->getStringValue($this->typeName, $execution->getExpressionContext()); $name = $this->getStringValue($this->name, $execution->getExpressionContext()); $task = $engine->createDelegateTask($typeName); if (!$task instanceof DelegateTaskInterface) { throw new \RuntimeException('Invalid service task implementation: ' . get_class($task)); } $engine->debug('Execute delegate task "{task}" implemented by <{class}>', ['task' => $name, 'class' => get_class($task)]); $task->execute(new DelegateExecution($execution)); $engine->notify(new TaskExecutedEvent($name, new DelegateExecution($execution), $engine)); $this->leave($execution); }
/** * {@inheritdoc} */ public function executeCommand(ProcessEngine $engine) { $def = $engine->getRepositoryService()->createProcessDefinitionQuery()->processDefinitionId($this->definitionId)->findOne(); $definition = $def->getModel(); $startNode = $definition->findNode($this->startNodeId); $process = new VirtualExecution(UUID::createRandom(), $engine, $definition); $process->setBusinessKey($this->businessKey); $process->setNode($startNode); foreach (unserialize($this->variables) as $k => $v) { $process->setVariable($k, $v); } $engine->registerExecution($process); $engine->info('Started {process} using process definition "{key}" ({id})', ['process' => (string) $process, 'key' => $def->getKey(), 'id' => (string) $def->getId()]); $process->execute($startNode); return $process->getId(); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $execution->getEngine()->debug('Reached terminate end event "{name}"', ['name' => $this->getStringValue($this->name, $execution->getExpressionContext())]); $engine = $execution->getEngine(); $engine->notify(new ActivityCompletedEvent($execution->getNode()->getId(), $execution, $engine)); $root = $execution->getScopeRoot(); $root->setNode($execution->getNode()); $root->setTransition($execution->getTransition()); $root->terminate(false); }
/** * {@inheritdoc} */ public function executeJob(Job $job, VirtualExecution $execution, ProcessEngine $engine) { if ($execution->isTerminated()) { throw new \RuntimeException(sprintf('%s is terminated', $execution)); } $data = (array) $job->getHandlerData(); $command = $data[self::PARAM_COMMAND]; if (!$command instanceof CommandInterface) { throw new \RuntimeException(sprintf('Expecting command, given %s', is_object($command) ? get_class($command) : gettype($command))); } // Move execution to start node if param is set. if (array_key_exists(self::PARAM_NODE_ID, $data)) { $execution->setNode($execution->getProcessModel()->findNode($data[self::PARAM_NODE_ID])); $engine->debug('Moved {execution} to node "{node}"', ['execution' => (string) $execution, 'node' => $execution->getNode()->getId()]); } $engine->debug('Executing async command {cmd} using {execution}', ['cmd' => get_class($command), 'execution' => (string) $execution]); $engine->pushCommand($command); }
/** * {@inheritdoc} */ public function interrupt(VirtualExecution $execution, array $transitions = NULL) { $engine = $execution->getEngine(); $root = $execution->getScope(); $params = ['e1' => $root->getId()]; $i = 1; foreach ($root->findChildExecutions() as $child) { $params['e' . ++$i] = $child->getId(); } $placeholders = implode(', ', array_map(function ($p) { return ':' . $p; }, array_keys($params))); $stmt = $engine->prepareQuery("SELECT `id` FROM `#__bpmn_user_task` WHERE `execution_id` IN ({$placeholders})"); $stmt->bindAll($params); $stmt->transform('id', new UUIDTransformer()); $stmt->execute(); foreach ($stmt->fetchColumns('id') as $taskId) { $engine->executeCommand(new RemoveUserTaskCommand($taskId)); } parent::interrupt($execution, $transitions); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $engine = $execution->getEngine(); $name = $this->getStringValue($this->name, $execution->getExpressionContext()); $engine->debug('Evaluate <{language}> script task "{task}"', ['language' => $this->language, 'task' => $name]); if ($this->scriptResource !== NULL) { $process = $engine->getRepositoryService()->createProcessDefinitionQuery()->processDefinitionId($execution->getProcessModel()->getId())->findOne(); $deployment = $engine->getRepositoryService()->createDeploymentQuery()->deploymentId($process->getDeploymentId())->findOne(); $resource = $deployment->findResourceById($process->getResourceId()); $file = str_replace('./', '', dirname($resource->getName()) . '/' . $this->scriptResource); $script = '?>' . $deployment->findResource($file)->getContents(); } else { $script = $this->script; } // Isolate scope to prevent manipulation of local / instance variables: $callback = function (DelegateExecution $execution, $script) { return eval($script); }; if (method_exists($callback, 'bindTo')) { $callback = $callback->bindTo(NULL, NULL); } $result = $callback(new DelegateExecution($execution), $script); if ($this->resultVariable !== NULL) { $execution->setVariable($this->resultVariable, $result); } $engine->notify(new TaskExecutedEvent($name, new DelegateExecution($execution), $engine)); $this->leave($execution); }
public function processSignal(VirtualExecution $execution, $signal, array $variables = [], array $delegation = []) { $startNode = $execution->getProcessModel()->findNode($this->startNodeId); $root = $execution->getScope(); $scope = $this->findScopeActivity($execution); if (!$this->isInterrupting()) { return $scope->leaveConcurrent($root, $startNode); } // Kill all remaining concurrent executions within the scope activity: foreach ($root->findChildExecutions() as $child) { $child->terminate(false); } $scope->clearEventSubscriptions($root, $scope->getActivityId()); $root->setNode($this->findScopeNode($root)); $root->setActive(false); $root->waitForSignal(); $sub = $root->createExecution(false); $sub->setNode($startNode); $sub->waitForSignal(); $sub->getEngine()->notify(new ActivityCanceledEvent($this->attachedTo, $sub, $sub->getEngine())); // Delegate received signal to event sub process start event. $sub->signal($signal, $variables); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $engine = $execution->getEngine(); $name = $this->getStringValue($this->name, $execution->getExpressionContext()); $engine->debug('Execute expression in service task "{task}"', ['task' => $name]); $result = $this->getValue($this->expression, $execution->getExpressionContext()); if ($this->resultVariable !== NULL) { $execution->setVariable($this->resultVariable, $result); } $engine->notify(new TaskExecutedEvent($name, new DelegateExecution($execution), $engine)); $this->leave($execution); }
/** * @param VirtualExecution $execution * @return AbstractScopeActivity */ public function findScopeActivity(VirtualExecution $execution) { return $execution->getProcessModel()->findNode($this->attachedTo)->getBehavior(); }
/** * Collect all boundary events connected to the activity of the given execution. * * @param VirtualExecution $execution * @return array<Node> */ public function findAttachedBoundaryActivities(VirtualExecution $execution) { $model = $execution->getProcessModel(); $activities = []; foreach ($model->findNodes() as $node) { $behavior = $node->getBehavior(); if ($behavior instanceof AbstractBoundaryActivity) { if ($this->activityId == $behavior->getAttachedTo()) { $activities[] = $node; } } } return $activities; }
/** * {@inheritdoc} */ public function createEventSubscriptions(VirtualExecution $execution, $activityId, Node $node = NULL) { $execution->getEngine()->pushCommand(new CreateSignalSubscriptionCommand($this->signal, $execution, $activityId, $node === NULL ? $execution->getNode() : $node)); parent::createEventSubscriptions($execution, $activityId, $node); }
protected function dumpExecution(VirtualExecution $exec) { $node = $exec->getNode(); $nodeId = $node === NULL ? NULL : $node->getId(); printf("%s%s [ %s ]\n", str_repeat(' ', $exec->getExecutionDepth()), $nodeId, $exec->getId()); foreach ($exec->findChildExecutions() as $child) { $this->dumpExecution($child); } }
/** * {@inheritdoc} */ public function createEventSubscriptions(VirtualExecution $execution, $activityId, Node $node = NULL) { $execution->getEngine()->executeCommand(new CreateMessageSubscriptionCommand($this->message, $execution, $activityId, $node === NULL ? $execution->getNode() : $node)); }
public function __construct(VirtualExecution $execution) { $this->executionId = $execution->getId(); }
/** * Delegate signal to a target node using the same execution. * * @param VirtualExecution $execution * @param string $signal * @param array $variables * @param array $delegation * @return boolean Returns true if the signal could be delegated. */ protected function delegateSignal(VirtualExecution $execution, $signal, array $variables, array $delegation) { if (empty($delegation['nodeId'])) { return false; } $node = $execution->getProcessModel()->findNode($delegation['nodeId']); $execution->getEngine()->debug('Delegating signal <{signal}> to {node}', ['signal' => $signal === NULL ? 'NULL' : $signal, 'node' => (string) $node]); $execution->setNode($node); $execution->waitForSignal(); $execution->signal($signal, $variables); return true; }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $execution->getEngine()->pushCommand(new SignalEventReceivedCommand($this->signalName, NULL, [], $execution)); $execution->waitForSignal(); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $execution->waitForSignal(); }
/** * {@inheritdoc} */ public function enter(VirtualExecution $execution) { $execution->getEngine()->pushCommand(new ThrowMessageCommand($execution)); $execution->waitForSignal(); }
/** * {@inheritdoc} */ public function createEventSubscriptions(VirtualExecution $execution, $activityId, Node $node = NULL) { $execution->getEngine()->executeCommand(new CreateSignalSubscriptionCommand($this->signal, $execution, $activityId, $node, true)); }