Ingenerator\RunSingle\DbDriver

Complexity

Total Complexity

16

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	set_time_provider()	0	4	1
A	get_time()	0	5	1
A	get_lock()	0	21	3
A	garbage_collect()	0	15	2
A	release_lock()	0	8	1
A	set_logger()	0	4	1
A	log()	0	6	2
A	build_lock_object()	0	14	1
A	list_locks()	0	13	3

<?php
/**
 * Database driver
 *
 * @author    Matthias Gisder <matthias@ingenerator.com>
 * @copyright 2014 inGenerator Ltd
 * @licence   BSD
 */

namespace Ingenerator\RunSingle;

use \Ingenerator\RunSingle\PdoDatabaseObject;
use \Psr\Log\LoggerInterface;

class DbDriver implements LockDriver
{

    const DATE_FORMAT = 'd/m/Y H:i:s';
    /**
     * @var \Ingenerator\RunSingle\PdoDatabaseObject
     */
    protected $db_object;

    /**
     * @var callable
     */
    protected $timeProvider = 'time';

    /**
     * @var \Psr\Log\LoggerInterface
     */
    protected $logger;

    /**
     * @param \Ingenerator\RunSingle\PdoDatabaseObject $db_object
     */
    public function __construct(PdoDatabaseObject $db_object)
    {
        $this->db_object = $db_object;
    }

    /**
     * @param callable $provider
     */
    public function set_time_provider($provider)
    {
        $this->timeProvider = $provider;
    }

    /**
     * @return int
     */
    protected function get_time()
    {
        $time = \call_user_func($this->timeProvider);
        return $time;
    }

    /**
     * @param  string $task_name
     * @param  int    $timeout
     * @param string  $lock_holder
     *
     * @return false|integer
     * @throws \Exception
     * @throws \PDOException
     */
    public function get_lock($task_name, $timeout, $lock_holder)
    {
        $timestamp = $this->get_time();

        try {
            $this->db_object->execute('INSERT INTO '.$this->db_object->get_db_table_name()." VALUES(:task_name, :timestamp, :timeout, :lock_holder)", array(
                ':task_name'   => $task_name,
                ':timestamp'   => $timestamp,
                ':timeout'     => $timeout,
                ':lock_holder' => $lock_holder,
            ));
        } catch (\PDOException $e) {
            if (\substr($e->getMessage(), 0, 69) === 'SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry') {
                return FALSE;
            } else {
                throw $e;
            }
        }

        return $timestamp;
    }

    /**
     * @param string $task_name
     *
     * @return void
     */
    public function garbage_collect($task_name)
    {
        $result = $this->db_object->fetch_all('SELECT * FROM '.$this->db_object->get_db_table_name().' WHERE task_name = :task_name AND (lock_timestamp + timeout) < :current_timestamp', array(
            ':task_name'         => $task_name,
            ':current_timestamp' => $this->get_time()
        ));
        if (!$result) {

The expression $result 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->log('debug', 'no stale locks found for task '.$task_name);
            return;
        }

        $lock = $this->build_lock_object($result[0]);
        $this->log('warning', \sprintf('stale locks found for lock:'.PHP_EOL.'    %s', $lock));
        $this->release_lock($result[0]['task_name'], $result[0]['lock_timestamp']);
    }

    /**
     * @param string $task_name
     * @param int    $lock_timestamp
     *
     * @return void
     */
    public function release_lock($task_name, $lock_timestamp)
    {
        $this->log('debug', 'releasing lock for task '.$task_name);
        $this->db_object->execute('DELETE FROM '.$this->db_object->get_db_table_name().' WHERE task_name = :task_name AND lock_timestamp = :lock_timestamp', array(
            ':task_name'      => $task_name,
            ':lock_timestamp' => $lock_timestamp
        ));
    }

    /**
     * @param LoggerInterface $logger
     */
    public function set_logger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     * Log only if logger is set.
     *
     * @param $level
     * @param $message
     */
    protected function log($level, $message)
    {
        if ($this->logger) {
            \call_user_func(array($this->logger, $level), $message);
        }
    }

    /**
     * @param array $result
     *
     * @return Lock
     */
    protected function build_lock_object($result)
    {
        $data = array(
            'task_name' => $result['task_name'],
            'lock_id' => $result['lock_timestamp'],
            'timeout' => $result['timeout'],
            'lock_holder' => $result['lock_holder'],
            'expires' => new \DateTime('@'.($result['lock_timestamp'] + $result['timeout'])),
            'locked_at' => new \DateTime('@'.($result['lock_timestamp'])),
        );
        $lock_obj = new Lock($data);

        return $lock_obj;
    }

    /**
     * Return a list of locks.
     *
     * @return array
     */
    public function list_locks()
    {
        $result = $this->db_object->fetch_all('SELECT * FROM '.$this->db_object->get_db_table_name(), array());

        $locks = array();
        if ($result) {

The expression $result 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.

            foreach ($result as $result_item) {
                $locks[] = $this->build_lock_object($result_item);
            }
        }

        return $locks;
    }

}