DelayHandlerClient::pdoInitialize() - Code Metrics - Inspection of "Refactoring" - VIPnytt/RobotsTxtParser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d4f070...1ddfcf )

by Jan-Petter

created 2016-06-18 22:27 UTC

DelayHandlerClient::pdoInitialize() A

↳ Parent: DelayHandlerClient

Complexity

Conditions	4
Paths	6

Size

Total Lines	17
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	17
rs	9.2
cc	4
eloc	12
nc	6
nop	1

<?php
namespace vipnytt\RobotsTxtParser\Client\Directives;

use PDO;
use vipnytt\RobotsTxtParser\Exceptions\SQLException;
use vipnytt\RobotsTxtParser\SQL\SQLInterface;
use vipnytt\RobotsTxtParser\SQL\TableConstructor;
use vipnytt\UserAgentParser;

/**
 * Class DelayHandlerClient
 *
 * @package vipnytt\RobotsTxtParser\Client\Directives
 */
class DelayHandlerClient implements SQLInterface
{
    /**
     * Supported database drivers
     */
    const SUPPORTED_DRIVERS = [
        self::DRIVER_MYSQL,
    ];

    /**
     * Database connection
     * @var PDO
     */
    private $pdo;

    /**
     * PDO driver
     * @var string
     */
    private $driver;

    /**
     * Base UriClient
     * @var string
     */
    private $base;

    /**
     * User-agent
     * @var string
     */
    private $userAgent;

    /**
     * Delay
     * @var float|int
     */
    private $delay;

    /**
     * DelayClient constructor.
     *
     * @param PDO $pdo
     * @param string $baseUri
     * @param string $userAgent
     * @param float|int $delay
     * @throws SQLException
     */
    public function __construct(PDO $pdo, $baseUri, $userAgent, $delay)
    {
        $this->pdo = $this->pdoInitialize($pdo);
        $this->base = $baseUri;
        $uaStringParser = new UserAgentParser($userAgent);
        $this->userAgent = $uaStringParser->stripVersion();
        $this->delay = round($delay, 6, PHP_ROUND_HALF_UP);
    }

    /**
     * Initialize PDO connection
     *
     * @param PDO $pdo
     * @return PDO
     * @throws SQLException
     */
    private function pdoInitialize(PDO $pdo)
    {
        if ($pdo->getAttribute(PDO::ATTR_ERRMODE) === PDO::ERRMODE_SILENT) {
            $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
        }
        $pdo->setAttribute(PDO::ATTR_CASE, PDO::CASE_NATURAL);
        $pdo->exec('SET NAMES ' . self::SQL_ENCODING);
        $this->driver = $pdo->getAttribute(PDO::ATTR_DRIVER_NAME);
        if (!in_array($this->driver, self::SUPPORTED_DRIVERS)) {
            throw new SQLException('Unsupported database. ' . self::README_SQL_DELAY);
        }
        $tableConstructor = new TableConstructor($pdo, self::TABLE_DELAY);
        if ($tableConstructor->exists() === false) {
            $tableConstructor->create(file_get_contents(__DIR__ . '/../../SQL/delay.sql'), self::README_SQL_DELAY);
        }
        return $pdo;
    }

    /**
     * Queue
     *
     * @return float|int
     */
    public function getQueue()
    {
        if ($this->delay == 0) {
            return 0;
        }
        $query = $this->pdo->prepare(<<<SQL
SELECT GREATEST(0, (microTime / 1000000) - UNIX_TIMESTAMP(CURTIME(6))) AS sec
FROM robotstxt__delay0
WHERE base = :base AND userAgent = :userAgent;
SQL
        );
        $query->bindParam(':base', $this->base, PDO::PARAM_STR);
        $query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
        $query->execute();
        if ($query->rowCount() > 0) {
            $row = $query->fetch(PDO::FETCH_ASSOC);
            return $row['sec'];
        }
        return 0;
    }

    /**
     * Reset queue
     *
     * @return bool
     */
    public function reset()
    {
        $query = $this->pdo->prepare(<<<SQL
DELETE FROM robotstxt__delay0
WHERE base = :base AND userAgent = :useragent;
SQL
        );
        $query->bindParam(':base', $this->base, PDO::PARAM_INT);
        $query->bindParam(':useragent', $this->userAgent, PDO::PARAM_INT);
        return $query->execute();
    }

    /**
     * Sleep
     *
     * @return float|int
     */
    public function sleep()
    {
        $start = microtime(true);
        $until = $this->getTimeSleepUntil();
        if (microtime(true) > $until) {
            return 0;
        }
        try {
            time_sleep_until($until);
        } catch (\Exception $warning) {
            // Timestamp already in the past
        }
        return microtime(true) - $start;
    }

    /**
     * Timestamp with milliseconds
     *
     * @return float|int
     * @throws SQLException
     */
    public function getTimeSleepUntil()
    {
        if ($this->delay == 0) {
            return 0;
        }
        $query = $this->pdo->prepare(<<<SQL
SELECT
  microTime,
  UNIX_TIMESTAMP()
FROM robotstxt__delay0
WHERE base = :base AND userAgent = :userAgent;
SQL
        );
        $query->bindParam(':base', $this->base, PDO::PARAM_STR);
        $query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
        $query->execute();
        $this->increment();
        if ($query->rowCount() > 0) {
            $row = $query->fetch(PDO::FETCH_ASSOC);
            if (abs(time() - $row['UNIX_TIMESTAMP()']) > 10) {
                throw new SQLException('`PHP server` and `SQL server` timestamps are out of sync. Please fix!');
            }
            return $row['microTime'] / 1000000;
        }
        return 0;
    }

    /**
     * Set new delayUntil timestamp
     *
     * @return bool
     */
    private function increment()
    {
        $query = $this->pdo->prepare(<<<SQL
INSERT INTO robotstxt__delay0 (base, userAgent, microTime, lastDelay)
VALUES (:base, :userAgent, (UNIX_TIMESTAMP(CURTIME(6)) + :delay) * 1000000, ROUND(:delay))
ON DUPLICATE KEY UPDATE
  microTime = GREATEST((UNIX_TIMESTAMP(CURTIME(6)) + :delay) * 1000000, microTime + (:delay * 1000000)),
  lastDelay = ROUND(:delay);
SQL
        );
        $query->bindParam(':base', $this->base, PDO::PARAM_STR);
        $query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
        $query->bindParam(':delay', $this->delay, is_int($this->delay) ? PDO::PARAM_INT : PDO::PARAM_STR);
        return $query->execute();
    }
}


1			<?php
2			namespace vipnytt\RobotsTxtParser\Client\Directives;
3
4			use PDO;
5			use vipnytt\RobotsTxtParser\Exceptions\SQLException;
6			use vipnytt\RobotsTxtParser\SQL\SQLInterface;
7			use vipnytt\RobotsTxtParser\SQL\TableConstructor;
8			use vipnytt\UserAgentParser;
9
10			/**
11			* Class DelayHandlerClient
12			*
13			* @package vipnytt\RobotsTxtParser\Client\Directives
14			*/
15			class DelayHandlerClient implements SQLInterface
16			{
17			/**
18			* Supported database drivers
19			*/
20			const SUPPORTED_DRIVERS = [
21			self::DRIVER_MYSQL,
22			];
23
24			/**
25			* Database connection
26			* @var PDO
27			*/
28			private $pdo;
29
30			/**
31			* PDO driver
32			* @var string
33			*/
34			private $driver;
35
36			/**
37			* Base UriClient
38			* @var string
39			*/
40			private $base;
41
42			/**
43			* User-agent
44			* @var string
45			*/
46			private $userAgent;
47
48			/**
49			* Delay
50			* @var float\|int
51			*/
52			private $delay;
53
54			/**
55			* DelayClient constructor.
56			*
57			* @param PDO $pdo
58			* @param string $baseUri
59			* @param string $userAgent
60			* @param float\|int $delay
61			* @throws SQLException
62			*/
63			public function __construct(PDO $pdo, $baseUri, $userAgent, $delay)
64			{
65			$this->pdo = $this->pdoInitialize($pdo);
66			$this->base = $baseUri;
67			$uaStringParser = new UserAgentParser($userAgent);
68			$this->userAgent = $uaStringParser->stripVersion();
69			$this->delay = round($delay, 6, PHP_ROUND_HALF_UP);
70			}
71
72			/**
73			* Initialize PDO connection
74			*
75			* @param PDO $pdo
76			* @return PDO
77			* @throws SQLException
78			*/
79			private function pdoInitialize(PDO $pdo)
80			{
81			if ($pdo->getAttribute(PDO::ATTR_ERRMODE) === PDO::ERRMODE_SILENT) {
82			$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
83			}
84			$pdo->setAttribute(PDO::ATTR_CASE, PDO::CASE_NATURAL);
85			$pdo->exec('SET NAMES ' . self::SQL_ENCODING);
86			$this->driver = $pdo->getAttribute(PDO::ATTR_DRIVER_NAME);
87			if (!in_array($this->driver, self::SUPPORTED_DRIVERS)) {
88			throw new SQLException('Unsupported database. ' . self::README_SQL_DELAY);
89			}
90			$tableConstructor = new TableConstructor($pdo, self::TABLE_DELAY);
91			if ($tableConstructor->exists() === false) {
92			$tableConstructor->create(file_get_contents(__DIR__ . '/../../SQL/delay.sql'), self::README_SQL_DELAY);
93			}
94			return $pdo;
95			}
96
97			/**
98			* Queue
99			*
100			* @return float\|int
101			*/
102			public function getQueue()
103			{
104			if ($this->delay == 0) {
105			return 0;
106			}
107			$query = $this->pdo->prepare(<<<SQL
108			SELECT GREATEST(0, (microTime / 1000000) - UNIX_TIMESTAMP(CURTIME(6))) AS sec
109			FROM robotstxt__delay0
110			WHERE base = :base AND userAgent = :userAgent;
111			SQL
112			);
113			$query->bindParam(':base', $this->base, PDO::PARAM_STR);
114			$query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
115			$query->execute();
116			if ($query->rowCount() > 0) {
117			$row = $query->fetch(PDO::FETCH_ASSOC);
118			return $row['sec'];
119			}
120			return 0;
121			}
122
123			/**
124			* Reset queue
125			*
126			* @return bool
127			*/
128			public function reset()
129			{
130			$query = $this->pdo->prepare(<<<SQL
131			DELETE FROM robotstxt__delay0
132			WHERE base = :base AND userAgent = :useragent;
133			SQL
134			);
135			$query->bindParam(':base', $this->base, PDO::PARAM_INT);
136			$query->bindParam(':useragent', $this->userAgent, PDO::PARAM_INT);
137			return $query->execute();
138			}
139
140			/**
141			* Sleep
142			*
143			* @return float\|int
144			*/
145			public function sleep()
146			{
147			$start = microtime(true);
148			$until = $this->getTimeSleepUntil();
149			if (microtime(true) > $until) {
150			return 0;
151			}
152			try {
153			time_sleep_until($until);
154			} catch (\Exception $warning) {
155			// Timestamp already in the past
156			}
157			return microtime(true) - $start;
158			}
159
160			/**
161			* Timestamp with milliseconds
162			*
163			* @return float\|int
164			* @throws SQLException
165			*/
166			public function getTimeSleepUntil()
167			{
168			if ($this->delay == 0) {
169			return 0;
170			}
171			$query = $this->pdo->prepare(<<<SQL
172			SELECT
173			microTime,
174			UNIX_TIMESTAMP()
175			FROM robotstxt__delay0
176			WHERE base = :base AND userAgent = :userAgent;
177			SQL
178			);
179			$query->bindParam(':base', $this->base, PDO::PARAM_STR);
180			$query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
181			$query->execute();
182			$this->increment();
183			if ($query->rowCount() > 0) {
184			$row = $query->fetch(PDO::FETCH_ASSOC);
185			if (abs(time() - $row['UNIX_TIMESTAMP()']) > 10) {
186			throw new SQLException('`PHP server` and `SQL server` timestamps are out of sync. Please fix!');
187			}
188			return $row['microTime'] / 1000000;
189			}
190			return 0;
191			}
192
193			/**
194			* Set new delayUntil timestamp
195			*
196			* @return bool
197			*/
198			private function increment()
199			{
200			$query = $this->pdo->prepare(<<<SQL
201			INSERT INTO robotstxt__delay0 (base, userAgent, microTime, lastDelay)
202			VALUES (:base, :userAgent, (UNIX_TIMESTAMP(CURTIME(6)) + :delay) * 1000000, ROUND(:delay))
203			ON DUPLICATE KEY UPDATE
204			microTime = GREATEST((UNIX_TIMESTAMP(CURTIME(6)) + :delay) * 1000000, microTime + (:delay * 1000000)),
205			lastDelay = ROUND(:delay);
206			SQL
207			);
208			$query->bindParam(':base', $this->base, PDO::PARAM_STR);
209			$query->bindParam(':userAgent', $this->userAgent, PDO::PARAM_STR);
210			$query->bindParam(':delay', $this->delay, is_int($this->delay) ? PDO::PARAM_INT : PDO::PARAM_STR);
211			return $query->execute();
212			}
213			}
214

VIPnytt / RobotsTxtParser

Push — master ( d4f070...1ddfcf )

DelayHandlerClient::pdoInitialize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like