PlaygroundCore\Service\Cron

Complexity

Total Complexity

78

Size/Duplication

Total Lines	669
Duplicated Lines	1.49 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	7
Bugs	4	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	run()	0	8	1
B	getCronjobs()	0	25	5
A	setCronjobs()	0	6	1
A	getPending()	0	10	2
A	resetPending()	0	6	1
C	process()	0	69	7
B	schedule()	0	54	6
A	cleanup()	0	8	1
B	recoverRunning()	0	23	4
B	cleanLog()	0	28	4
A	register()	0	8	1
A	tryLockJob()	0	15	2
C	matchTime()	0	22	7
D	matchTimeComponent()	10	83	17
B	exprToNumeric()	0	42	5
A	setScheduleAhead()	0	6	1
A	getScheduleAhead()	0	4	1
A	setScheduleLifetime()	0	6	1
A	getScheduleLifeTime()	0	4	1
A	setMaxRunningTime()	0	6	1
A	getMaxRunningtime()	0	4	1
A	setSuccessLogLifetime()	0	6	1
A	getSuccessLogLifetime()	0	4	1
A	setFailureLogLifetime()	0	6	1
A	getFailureLogLifetime()	0	4	1
A	setEm()	0	6	1
A	getEm()	0	8	2

<?php
namespace PlaygroundCore\Service;

use PlaygroundCore\Entity;
use PlaygroundCore\Exception;
use PlaygroundCore\Mapper;
use PlaygroundCore\Service\Registry;
use Doctrine\ORM\EntityManager;
use Zend\ServiceManager\ServiceManager;
use ZfcBase\EventManager\EventProvider;
use Zend\ServiceManager\ServiceLocatorInterface;

/**
 * main Cron class
 *
 * handle cron job registration, validation, scheduling, running, and cleanup
 *
 * @author heartsentwined <heartsentwined@cogito-lab.com>
 * @license GPL http://opensource.org/licenses/gpl-license.php
 */
class Cron extends EventProvider
{
    /**
     * how long ahead to schedule cron jobs
     *
     * @var int (minute)
     */
    protected $scheduleAhead = 60;

    /**
     * the Doctrine ORM Entity Manager
     *
     * @var EntityManager
     */
    protected $em;

    /**
     * List of cron jobs to be managed
     */
    protected $cronjobs;

    /**
     * how long before a scheduled job is considered missed
     *
     * @var int (minute)
     */
    protected $scheduleLifetime = 60;

    /**
     * maximum running time of each cron job
     *
     * @var int (minute)
     */
    protected $maxRunningTime = 60;

    /**
     * how long to keep successfully completed cron job logs
     *
     * @var int (minute)
     */
    protected $successLogLifetime = 300;

    /**
     * how long to keep failed (missed / error) cron job logs
     *
     * @var int (minute)
     */
    protected $failureLogLifetime = 10080;

    /**
     * set of pending cron jobs
     *
     * wrapped the Repo function here to implement a (crude) cache feature
     *
     * @var array of Entity\Cronjob
     */
    protected $pending;

    /**
     *
     * @var ServiceManager
     */
    protected $serviceLocator;

    public function __construct(ServiceLocatorInterface $locator)
    {
        $this->serviceLocator = $locator;

$locator is of type object<Zend\ServiceManager\ServiceLocatorInterface>, but the property $serviceLocator was declared to be of type object<Zend\ServiceManager\ServiceManager>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    /**
     * main entry function
     *
     * 1. schedule new cron jobs
     * 2. process cron jobs
     * 3. cleanup old logs
     *
     * @return self
     */
    public function run()
    {
        $this->schedule()
        ->process()
        ->cleanup();

        return $this;
    }

    /**
     * trigger an event and fetch crons
     * Return array
     */
    public function getCronjobs()
    {
        if (!$this->cronjobs) {
            $cronjobs = array();

            $results = $this->serviceLocator
                ->get('application')
                ->getEventManager()
                ->trigger(__FUNCTION__, $this, array(
                        'cronjobs' => $cronjobs
                ));

            if ($results) {
                foreach ($results as $key => $cron) {
                    foreach ($cron as $id => $conf) {
                        $cronjobs[$id] = $conf;
                    }
                }
            }

            $this->setCronjobs($cronjobs);
        }

        return $this->cronjobs;
    }

    /**
     *
     */
    public function setCronjobs($cronjobs)
    {
        $this->cronjobs = $cronjobs;

        return $this;
    }

    public function getPending()
    {
        if (!$this->pending) {

The expression $this->pending of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->pending = $this->getEm()
                ->getRepository('PlaygroundCore\Entity\Cronjob')
                ->getPending();
        }

        return $this->pending;
    }

    public function resetPending()
    {
        $this->pending = null;

It seems like null of type null is incompatible with the declared type array of property $pending.

        return $this;
    }

    /**
     * run cron jobs
     *
     * @return self
     */
    public function process()
    {
        $em = $this->getEm();
        $cronRegistry = $this->getCronjobs();
        $pending = $this->getPending();
        $scheduleLifetime = $this->scheduleLifetime * 60; //convert min to sec

        $now = new \DateTime;
        foreach ($pending as $job) {
            $scheduleTime = $job->getScheduleTime();

            if ($scheduleTime > $now) {
                continue;
            }

            try {
                $errorStatus = Mapper\Cronjob::STATUS_ERROR;

                $missedTime = clone $now;
                $timestamp = $missedTime->getTimestamp();
                $timestamp -= $scheduleLifetime;
                $missedTime->setTimestamp($timestamp);

                if ($scheduleTime < $missedTime) {
                    $errorStatus = Mapper\Cronjob::STATUS_MISSED;
                    throw new Exception\RuntimeException(
                        'too late for job'
                    );
                }

                $code = $job->getCode();

                if (!isset($cronRegistry[$code])) {
                    throw new Exception\RuntimeException(sprintf(
                        'job "%s" undefined in cron registry',
                        $code
                    ));
                }

                if (!$this->tryLockJob($job)) {
                    //another cron started this job intermittently. skip.
                    continue;
                }

                //run job now
                $callback = $cronRegistry[$code]['callback'];
                $args = $cronRegistry[$code]['args'];

                $job->setExecuteTime(new \DateTime);
                $em->persist($job);

                call_user_func_array($callback, $args);

                $job
                    ->setStatus(Mapper\Cronjob::STATUS_SUCCESS)
                    ->setFinishTime(new \DateTime);
            } catch (\Exception $e) {
                $job
                    ->setStatus($errorStatus)
                    ->setErrorMsg($e->getMessage())
                    ->setStackTrace($e->getTraceAsString());
            }

            $em->persist($job);
        }
        $em->flush();
        
        return $this;
    }

    /**
     * schedule cron jobs
     *
     * @return self
     */
    public function schedule()
    {
        $em = $this->getEm();
        $pending = $this->getPending();
        $exists = array();
        foreach ($pending as $job) {
            $identifier = $job->getCode();
            $identifier .= $job->getScheduleTime()->getTimeStamp();
            $exists[$identifier] = true;
        }

        $scheduleAhead = $this->getScheduleAhead() * 60;

        $cronRegistry = $this->getCronjobs();

        foreach ($cronRegistry as $code => $item) {
            $now = time();
            $timeAhead = $now + $scheduleAhead;

            for ($time = $now; $time < $timeAhead; $time += 60) {
                $scheduleTime = new \DateTime();
                $scheduleTime->setTimestamp($time);
                $scheduleTime->setTime(
                    $scheduleTime->format('H'),
                    $scheduleTime->format('i')
                );
                $scheduleTimestamp = $scheduleTime->getTimestamp();

                $identifier = $code . $scheduleTimestamp;
                if (isset($exists[$identifier])) {
                    //already scheduled
                    continue;
                }

                $job = new Entity\Cronjob;
                if ($this->matchTime(
                    $scheduleTimestamp,
                    $item['frequency']
                )) {
                    $job
                        ->setCode($code)
                        ->setStatus(Mapper\Cronjob::STATUS_PENDING)
                        ->setCreateTime(new \DateTime)
                        ->setScheduleTime($scheduleTime);
                    $em->persist($job);
                    $exists[$identifier] = true;
                }
            }
        }

        $em->flush();

        return $this;
    }

    /**
     * perform various cleanup work
     *
     * @return self
     */
    public function cleanup()
    {
        $this
            ->recoverRunning()
            ->cleanLog();

        return $this;
    }

    public function recoverRunning()
    {
        $em = $this->getEm();
        $running = $em->getRepository('PlaygroundCore\Entity\Cronjob')
            ->getRunning();
        $expiryTime = time() - $this->getMaxRunningTime() * 60;

        foreach ($running as $job) {
            if ($job->getExecuteTime()
                && $job->getExecuteTime()->getTimestamp() < $expiryTime) {
                $job
                    ->setStatus(Mapper\Cronjob::STATUS_PENDING)
                    ->setErrorMsg(null)
                    ->setStackTrace(null)
                    ->setScheduleTime(new \DateTime)
                    ->setExecuteTime(null);
            }
        }

        $this->getEm()->flush();

        return $this;
    }

    /**
     * delete old cron job logs
     *
     * @return self
     */
    public function cleanLog()
    {
        $em = $this->getEm();
        $lifetime = array(
            Mapper\Cronjob::STATUS_SUCCESS  =>
                $this->getSuccessLogLifetime() * 60,
            Mapper\Cronjob::STATUS_MISSED   =>
                $this->getFailureLogLifetime() * 60,
            Mapper\Cronjob::STATUS_ERROR    =>
                $this->getFailureLogLifetime() * 60,
        );

        $history = $em->getRepository('PlaygroundCore\Entity\Cronjob')
            ->getHistory();

        $now = time();
        foreach ($history as $job) {
            if ($job->getExecuteTime()
                && $job->getExecuteTime()->getTimestamp()
                    < $now - $lifetime[$job->getStatus()]) {
                $em->remove($job);
            }
        }

        $em->flush();

        return $this;
    }

    /**
     * wrapper function
     * @see Registry::register()
     */
    public static function register(
        $code,
        $frequency,
        $callback,
        array $args = array()
    ) {
        Registry::register($code, $frequency, $callback, $args);
    }

    /**
     * try to acquire a lock on a cron job
     *
     * set a job to 'running' only if it is currently 'pending'
     *
     * @param  Entity\Cronjob $job
     * @return bool
     */
    public function tryLockJob(Entity\Cronjob $job)
    {
        $em = $this->getEm();
        if ($job->getStatus() === Mapper\Cronjob::STATUS_PENDING) {
            $job->setStatus(Mapper\Cronjob::STATUS_RUNNING);
            $em->persist($job);
            $em->flush();

            // flush() succeeded if reached here;
            // otherwise an Exception would have been thrown
            return true;
        }

        return false;
    }

    /**
     * determine whether a given time falls within the given cron expr
     *
     * @param string|numeric $time
     *      timestamp or strtotime()-compatible string
     * @param string $expr
     *      any valid cron expression, in addition supporting:
     *      range: '0-5'
     *      range + interval: '10-59/5'
     *      comma-separated combinations of these: '1,4,7,10-20'
     *      English months: 'january'
     *      English months (abbreviated to three letters): 'jan'
     *      English weekdays: 'monday'
     *      English weekdays (abbreviated to three letters): 'mon'
     *      These text counterparts can be used in all places where their
     *          numerical counterparts are allowed, e.g. 'jan-jun/2'
     *      A full example:
     *          '0-5,10-59/5 * 2-10,15-25 january-june/2 mon-fri' -
     *          every minute between minute 0-5 + every 5th min between 10-59
     *          every hour
     *          every day between day 2-10 and day 15-25
     *          every 2nd month between January-June
     *          Monday-Friday
     * @throws Exception\InvalidArgumentException on invalid cron expression
     * @return bool
     */
    public static function matchTime($time, $expr)
    {
        $cronExpr = preg_split('/\s+/', $expr, null, PREG_SPLIT_NO_EMPTY);
        if (count($cronExpr) !== 5) {
            throw new Exception\InvalidArgumentException(sprintf(
                'cron expression should have exactly 5 arguments, "%s" given',
                $expr
            ));
        }

        if (is_string($time)) {
            $time = strtotime($time);
        }

        $date = getdate($time);

        return self::matchTimeComponent($cronExpr[0], $date['minutes'])
        && self::matchTimeComponent($cronExpr[1], $date['hours'])
        && self::matchTimeComponent($cronExpr[2], $date['mday'])
        && self::matchTimeComponent($cronExpr[3], $date['mon'])
        && self::matchTimeComponent($cronExpr[4], $date['wday']);
    }

    /**
     * match a cron expression component to a given corresponding date/time
     *
     * In the expression, * * * * *, each component
     *      *[1] *[2] *[3] *[4] *[5]
     * will correspond to a getdate() component
     * 1. $date['minutes']
     * 2. $date['hours']
     * 3. $date['mday']
     * 4. $date['mon']
     * 5. $date['wday']
     *
     * @see self::exprToNumeric() for additional valid string values
     *
     * @param  string                             $expr
     * @param  numeric                            $num
     * @throws Exception\InvalidArgumentException on invalid expression
     * @return bool
     */
    public static function matchTimeComponent($expr, $num)
    {
        //handle all match
        if ($expr === '*') {
            return true;
        }

        //handle multiple options
        if (strpos($expr, ',') !== false) {
            $args = explode(',', $expr);
            foreach ($args as $arg) {
                if (self::matchTimeComponent($arg, $num)) {
                    return true;
                }
            }

            return false;
        }

        //handle modulus
        if (strpos($expr, '/') !== false) {
            $arg = explode('/', $expr);
            if (count($arg) !== 2) {
                throw new Exception\InvalidArgumentException(sprintf(
                    'invalid cron expression component: '
                    . 'expecting match/modulus, "%s" given',
                    $expr
                ));
            }
            if (!is_numeric($arg[1])) {
                throw new Exception\InvalidArgumentException(sprintf(
                    'invalid cron expression component: '
                    . 'expecting numeric modulus, "%s" given',
                    $expr
                ));
            }

            $expr = $arg[0];
            $mod = $arg[1];
        } else {
            $mod = 1;
        }

        //handle all match by modulus
        if ($expr === '*') {
            $from = 0;
            $to   = 60;
        } //handle range
        elseif (strpos($expr, '-') !== false) {
            $arg = explode('-', $expr);
            if (count($arg) !== 2) {
                throw new Exception\InvalidArgumentException(sprintf(
                    'invalid cron expression component: '
                    . 'expecting from-to structure, "%s" given',
                    $expr
                ));
            }
            if (!is_numeric($arg[0])) {

This code seems to be duplicated across your project.

                $from = self::exprToNumeric($arg[0]);
            } else {
                $from = $arg[0];
            }
            if (!is_numeric($arg[1])) {

This code seems to be duplicated across your project.

                $to = self::exprToNumeric($arg[1]);
            } else {
                $to = $arg[1];
            }
        } //handle regular token
        else {
            $from = self::exprToNumeric($expr);
            $to = $from;
        }

        if ($from === false || $to === false) {
            throw new Exception\InvalidArgumentException(sprintf(
                'invalid cron expression component: '
                . 'expecting numeric or valid string, "%s" given',
                $expr
            ));
        }

        return ($num >= $from) && ($num <= $to) && ($num % $mod === 0);
    }

    /**
     * parse a string month / weekday expression to its numeric equivalent
     *
     * @param string|numeric $value
     *      accepts, case insensitive,
     *      - Jan - Dec
     *      - Sun - Sat
     *      - (or their long forms - only the first three letters important)
     * @return int|false
     */
    public static function exprToNumeric($value)
    {
        static $data = array(
                'jan'   => 1,
                'feb'   => 2,
                'mar'   => 3,
                'apr'   => 4,
                'may'   => 5,
                'jun'   => 6,
                'jul'   => 7,
                'aug'   => 8,
                'sep'   => 9,
                'oct'   => 10,
                'nov'   => 11,
                'dec'   => 12,

                'sun'   => 0,
                'mon'   => 1,
                'tue'   => 2,
                'wed'   => 3,
                'thu'   => 4,
                'fri'   => 5,
                'sat'   => 6,
        );

        if (is_numeric($value)) {
            if (in_array((int) $value, $data, true)) {
                return $value;

The return type of return $value; (integer|double|string) is incompatible with the return type documented by PlaygroundCore\Service\Cron::exprToNumeric of type integer|false.

            } else {
                return false;
            }
        }

        if (is_string($value)) {
            $value = strtolower(substr($value, 0, 3));
            if (isset($data[$value])) {
                return $data[$value];
            }
        }

        return false;
    }

    public function setScheduleAhead($scheduleAhead)
    {
        $this->scheduleAhead = $scheduleAhead;

        return $this;
    }

    public function getScheduleAhead()
    {
        return $this->scheduleAhead;
    }

    public function setScheduleLifetime($scheduleLifetime)
    {
        $this->scheduleLifetime = $scheduleLifetime;

        return $this;
    }

    public function getScheduleLifeTime()
    {
        return $this->scheduleLifeTime;

The property scheduleLifeTime does not seem to exist. Did you mean scheduleLifetime?

    }

    public function setMaxRunningTime($maxRunningTime)
    {
        $this->maxRunningTime = $maxRunningTime;

        return $this;
    }

    public function getMaxRunningtime()
    {
        return $this->maxRunningTime;
    }

    public function setSuccessLogLifetime($successLogLifetime)
    {
        $this->successLogLifetime = $successLogLifetime;

        return $this;
    }
    public function getSuccessLogLifetime()
    {
        return $this->successLogLifetime;
    }

    public function setFailureLogLifetime($failureLogLifetime)
    {
        $this->failureLogLifetime = $failureLogLifetime;

        return $this;
    }

    public function getFailureLogLifetime()
    {
        return $this->failureLogLifetime;
    }

    public function setEm(EntityManager $em)

You have injected the EntityManager via parameter $em. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

    {
        $this->em = $em;

        return $this;
    }

    public function getEm()
    {
        if (!$this->em) {
            $this->setEm($this->serviceLocator->get('playgroundcore_doctrine_em'));

$this->serviceLocator->get('playgroundcore_doctrine_em') is of type object|array, but the function expects a object<Doctrine\ORM\EntityManager>.

        }

        return $this->em;
    }
}