Dtc\QueueBundle\Doctrine\DoctrineRunManager

Complexity

Total Complexity

15

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Test Coverage

Coverage

93.18%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getRunArchiveClass()	0	3	1
A	getRepository()	0	3	1
A	getObjectManager()	0	3	1
A	__construct()	0	5	1
A	persistRun()	0	4	1
A	pruneStalledRuns()	0	22	5
A	flush()	0	3	1
A	pruneArchivedRuns()	0	3	1
A	deleteOldRuns()	0	13	3

<?php

namespace Dtc\QueueBundle\Doctrine;

use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\ObjectRepository;
use Dtc\QueueBundle\Manager\RunManager;
use Dtc\QueueBundle\Model\Run;

abstract class DoctrineRunManager extends RunManager
{
    /** @var ObjectManager */
    protected $objectManager;

    /** @var string|null */
    protected $runArchiveClass;

    public function __construct(ObjectManager $objectManager, $runClass, $runArchiveClass)
    {
        $this->runArchiveClass = $runArchiveClass;
        $this->objectManager = $objectManager;
        parent::__construct($runClass);
    }

    /**
     * @return ObjectManager
     */
    public function getObjectManager()
    {
        return $this->objectManager;
    }

    /**
     * @return ObjectRepository
     */
    public function getRepository()
    {
        return $this->getObjectManager()->getRepository($this->getRunClass());
    }

    /**
     * @return string|null
     */
    public function getRunArchiveClass()
    {
        return $this->runArchiveClass;
    }

    /**
     * @return int
     *
     * @throws \Exception
     */
    public function pruneStalledRuns()
    {
        $runs = $this->getOldLiveRuns();
        /** @var Run $run */
        $delete = [];

        foreach ($runs as $run) {
            $lastHeartbeat = $run->getLastHeartbeatAt();
            $time = time() - 3600;
            $processTimeout = $run->getProcessTimeout();
            $time -= $processTimeout;
            $oldDate = \DateTime::createFromFormat('U', strval($time));
            if (false === $oldDate) {
                throw new \Exception("Could not create DateTime object from $time");
            }
            $oldDate->setTimezone(new \DateTimeZone(date_default_timezone_get()));
            if (null === $lastHeartbeat || $oldDate > $lastHeartbeat) {
                $delete[] = $run;
            }
        }

        return $this->deleteOldRuns($delete);
    }

    /**
     * @return int
     */
    protected function deleteOldRuns(array $delete)
    {
        $count = count($delete);
        $objectManager = $this->getObjectManager();
        for ($i = 0; $i < $count; $i += 100) {
            $deleteList = array_slice($delete, $i, 100);
            foreach ($deleteList as $object) {
                $objectManager->remove($object);
            }
            $this->flush();
        }

        return $count;
    }

    protected function flush()
    {
        $this->getObjectManager()->flush();
    }

    /**
     * @param string $action
     */
    protected function persistRun(Run $run, $action = 'persist')
    {
        parent::persistRun($run, $action);
        $this->persist($run, $action);
    }

    /**
     * @return array
     */
    abstract protected function getOldLiveRuns();

    abstract protected function persist($object, $action = 'persist');

    abstract protected function removeOlderThan($objectName, $field, \DateTime $olderThan);

    public function pruneArchivedRuns(\DateTime $olderThan)
    {
        return $this->removeOlderThan($this->getRunArchiveClass(), 'endedAt', $olderThan);
    }
}