Loop.php

Go to the documentation of this file.

<?php

namespace Elgg\Upgrade;

use Elgg\Cli\Progress;
use Elgg\Exceptions\RuntimeException;
use Elgg\Logger;
use Elgg\Traits\Loggable;
use Symfony\Component\Console\Helper\ProgressBar;

class Loop {

    use Loggable;

    protected $upgrade;

    protected $result;

    protected $batch;

    protected $max_duration;

    protected $count;

    protected $processed;

    protected $offset;

    protected $progress;

    public function __construct(
        \ElggUpgrade $upgrade,
        Result $result,
        Progress $progress,
        Logger $logger
    ) {
        $this->upgrade = $upgrade;

        // Get the class taking care of the actual upgrading
        $this->batch = $upgrade->getBatch();
        if (!$this->batch) {
            throw new RuntimeException(elgg_echo('admin:upgrades:error:invalid_batch', [
                $upgrade->getDisplayName(),
                $upgrade->guid
            ]));
        }

        $this->result = $result;
        $this->progress = $progress;
        $this->logger = $logger;

        $this->count = $this->batch->countItems();
        $this->processed = (int) $upgrade->processed;
        $this->offset = (int) $upgrade->offset;
    }

    public function loop($max_duration = null): void {

        $started = microtime(true);

        $this->upgrade->setStartTime();
        $progress = $this->progress->start($this->upgrade->getDisplayName(), $this->count);

        while ($this->canContinue($started, $max_duration)) {
            $this->runBatch($progress);
        }

        $this->progress->finish($progress);

        $this->upgrade->processed = $this->processed;
        $this->upgrade->offset = $this->offset;

        if (!$this->isCompleted()) {
            return;
        }

        // Upgrade is finished
        if ($this->result->getFailureCount()) {
            // The upgrade was finished with errors. Reset offset
            // and errors so the upgrade can start from a scratch
            // if attempted to run again.
            $this->upgrade->processed = 0;
            $this->upgrade->offset = 0;
        } else {
            // Everything has been processed without errors
            // so the upgrade can be marked as completed.
            $this->upgrade->setCompleted();
            $this->result->markComplete();
        }

        $this->report();
    }

    protected function runBatch(ProgressBar $progress): void {
        try {
            $this->batch->run($this->result, $this->offset);
        } catch (\Exception $e) {
            $this->getLogger()->error($e);

            $this->result->addError($e->getMessage());
            $this->result->addFailures(1);
        }

        $failure_count = $this->result->getFailureCount();
        $success_count = $this->result->getSuccessCount();

        $total = $this->upgrade->processed + $failure_count + $success_count;

        $progress->advance($total - $this->processed);

        if ($this->batch->needsIncrementOffset()) {
            // Offset needs to incremented by the total amount of processed
            // items so the upgrade we won't get stuck upgrading the same
            // items over and over.
            $this->offset = $total;
        } else {
            // Offset doesn't need to be incremented, so we mark only
            // the items that caused a failure.
            $this->offset = $this->upgrade->offset + $failure_count;
        }

        $this->processed = $total;
    }

    protected function report(): void {
        $upgrade_name = $this->upgrade->getDisplayName();

        if ($this->upgrade->isCompleted()) {
            $ts = $this->upgrade->getCompletedTime();
            $dt = new \DateTime();
            $dt->setTimestamp((int) $ts);
            $format = elgg_get_config('date_format') ?: DATE_ATOM;

            if ($this->result->getFailureCount()) {
                elgg_register_error_message(elgg_echo('admin:upgrades:completed:errors', [
                    $upgrade_name,
                    $dt->format($format),
                    $this->result->getFailureCount(),
                ]));
            } else {
                elgg_register_success_message(elgg_echo('admin:upgrades:completed', [
                    $upgrade_name,
                    $dt->format($format),
                ]));
            }
        } else {
            elgg_register_error_message(elgg_echo('admin:upgrades:failed', [$upgrade_name]));
        }

        foreach ($this->result->getErrors() as $error) {
            $this->getLogger()->error($error);
        }
    }

    protected function canContinue($started, $max_duration = null): bool {
        if (!isset($max_duration)) {
            $max_duration = elgg_get_config('batch_run_time_in_secs');
        }

        if ($max_duration && (microtime(true) - $started) >= $max_duration) {
            return false;
        }

        return !$this->isCompleted();
    }

    protected function isCompleted(): bool {
        if ($this->batch->shouldBeSkipped()) {
            return true;
        }

        if ($this->result->wasMarkedComplete()) {
            return true;
        }
        
        if ($this->count === Batch::UNKNOWN_COUNT) {
            // the batch reports an unknown count and should mark the Result as complete when it's done
            return false;
        }
        
        if (!$this->batch->needsIncrementOffset()) {
            // the batch has some way of marking progress (like a delete) and the count items should reflect this
            return ($this->batch->countItems() - $this->result->getFailureCount()) <= 0;
        }

        return $this->processed >= $this->count;
    }
}