BasicTaskManager.php

Go to the documentation of this file.

<?php

namespace ILIAS\BackgroundTasks\Implementation\TaskManager;

use ILIAS\BackgroundTasks\Exceptions\Exception;
use ILIAS\BackgroundTasks\Implementation\Bucket\State;
use ILIAS\BackgroundTasks\Implementation\Tasks\UserInteraction\UserInteractionRequiredException;
use ILIAS\BackgroundTasks\Implementation\Values\ThunkValue;
use ILIAS\BackgroundTasks\Bucket;
use ILIAS\BackgroundTasks\Observer;
use ILIAS\BackgroundTasks\Persistence;
use ILIAS\BackgroundTasks\Task;
use ILIAS\BackgroundTasks\Task\UserInteraction\Option;
use ILIAS\BackgroundTasks\TaskManager;
use ILIAS\BackgroundTasks\Value;

class BasicTaskManager implements TaskManager
{

    protected $persistence;


    public function __construct(Persistence $persistence)
    {
        $this->persistence = $persistence;
    }


    public function executeTask(Task $task, Observer $observer)
    {
        $observer->notifyState(State::RUNNING);
        $values = $task->getInput();
        $final_values = [];
        $replace_thunk_values = false;
        foreach ($values as $value) {
            if (is_a($value, ThunkValue::class)) {
                $value = $this->executeTask($value->getParentTask(), $observer);
                $replace_thunk_values = true;
            }
            $final_values[] = $value;
        }

        if ($replace_thunk_values) {
            $task->setInput($final_values);
        }

        if (is_a($task, Task\Job::class)) {
            $job = $task;
            $observer->notifyCurrentTask($job);
            $value = $job->run($final_values, $observer);
            if (!$value->getType()->isExtensionOf($job->getOutputType())) {
                throw new Exception("The job " . $job->getType()
                                    . " did state to output a value of type "
                                    . $job->getOutputType() . " but outputted a value of type "
                                    . $value->getType());
            }
            $observer->notifyPercentage($job, 100);

            return $value;
        }

        if (is_a($task, Task\UserInteraction::class)) {
            $userInteraction = $task;
            $observer->notifyCurrentTask($userInteraction);
            $observer->notifyState(State::USER_INTERACTION);
            throw new UserInteractionRequiredException("User interaction required.");
        }

        throw new Exception("You need to execute a Job or a UserInteraction.");
    }


    public function run(Bucket $bucket)
    {
        $task = $bucket->getTask();
        $bucket->setCurrentTask($task);
        $observer = new NonPersistingObserver($bucket);

        try {
            $this->executeTask($task, $observer);
            $bucket->setState(State::FINISHED);
        } catch (UserInteractionRequiredException $e) {
            // We're okay!
            $this->persistence->saveBucketAndItsTasks($bucket);
        }
    }


    public function continueTask(Bucket $bucket, Option $option)
    {
        // We do the user interaction
        $bucket->userInteraction($option);
        if ($bucket->getState() != State::FINISHED) { // The job is not done after the user interaction, so we continue to run it.
            $this->run($bucket);
        } else {
            $this->persistence->deleteBucket($bucket);
        }
    }


    public function quitBucket(Bucket $bucket)
    {
        $this->persistence->deleteBucket($bucket);
    }
}