Driver::driverCheck() - Code Metrics - Inspection of "Merge branch 'v5' into final (#299)" - PHPSocialNetwork/phpfastcache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — final (ad8b8d)

by Georges

created 2016-07-01 17:57 UTC

Driver::driverCheck() A

↳ Parent: Driver

Complexity

Conditions	3
Paths	3

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	2
c	1
b	0
f	0
nc	3
nop	0
dl	0
loc	4
rs	10

<?php
/**
 *
 * This file is part of phpFastCache.
 *
 * @license MIT License (MIT)
 *
 * For full copyright and license information, please see the docs/CREDITS.txt file.
 *
 * @author Khoa Bui (khoaofgod)  <[email protected]> http://www.phpfastcache.com
 * @author Georges.L (Geolim4)  <[email protected]>
 *
 */

namespace phpFastCache\Drivers\Sqlite;

use PDO;
use PDOException;
use phpFastCache\Cache\ExtendedCacheItemInterface;
use phpFastCache\Core\DriverAbstract;
use phpFastCache\Core\PathSeekerTrait;
use phpFastCache\Core\StandardPsr6StructureTrait;
use phpFastCache\Entities\driverStatistic;
use phpFastCache\Exceptions\phpFastCacheDriverCheckException;
use phpFastCache\Exceptions\phpFastCacheDriverException;
use phpFastCache\Util\Directory;
use Psr\Cache\CacheItemInterface;

/**
 * Class Driver
 * @package phpFastCache\Drivers
 */
class Driver extends DriverAbstract
{
    use PathSeekerTrait;

    /**
     *
     */
    const FILE_DIR = 'sqlite';
    /**
     *
     */
    const INDEXING_FILE = 'indexing';

    /**
     * @var int
     */
    protected $maxSize = 10; // 10 mb

    /**
     * @var int
     */
    protected $currentDB = 1;

    /**
     * @var string
     */
    protected $SqliteDir = '';

    /**
     * @var null
     */
    protected $indexing;

    /**
     * Driver constructor.
     * @param array $config
     * @throws phpFastCacheDriverException
     */
    public function __construct(array $config = [])
    {
        $this->setup($config);

        if (!$this->driverCheck()) {
            throw new phpFastCacheDriverCheckException(sprintf(self::DRIVER_CHECK_FAILURE, $this->getDriverName()));
        } else {
            if (!file_exists($this->getSqliteDir()) && !@mkdir($this->getSqliteDir(), $this->setChmodAuto(), true)) {
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
                throw new phpFastCacheDriverException(sprintf('Sqlite cannot write in "%s", aborting...', $this->getPath()));
            } else {
                $this->driverConnect();
            }
        }
    }

    /**
     * @return string
     * @throws \phpFastCache\Exceptions\phpFastCacheCoreException
     */
    public function getSqliteDir()
    {
        return $this->SqliteDir ?: $this->getPath() . DIRECTORY_SEPARATOR . self::FILE_DIR;
    }

    /**
     * @return bool
     */
    public function driverCheck()
    {
        return extension_loaded('pdo_sqlite') && (is_writable($this->getSqliteDir()) || @mkdir($this->getSqliteDir(), $this->setChmodAuto(), true));
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
    }

    /**
     * INIT NEW DB
     * @param \PDO $db
     */
    public function initDB(\PDO $db)
    {
        $db->exec('drop table if exists "caching"');
        $db->exec('CREATE TABLE "caching" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "keyword" VARCHAR UNIQUE, "object" BLOB, "exp" INTEGER)');
        $db->exec('CREATE UNIQUE INDEX "cleanup" ON "caching" ("keyword","exp")');
        $db->exec('CREATE INDEX "exp" ON "caching" ("exp")');
        $db->exec('CREATE UNIQUE INDEX "keyword" ON "caching" ("keyword")');
    }

    /**
     * INIT Indexing DB
     * @param \PDO $db
     */
    public function initIndexing(\PDO $db)
    {

        // delete everything before reset indexing
        $dir = opendir($this->SqliteDir);
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
        while ($file = readdir($dir)) {
            if ($file != '.' && $file != '..' && $file != 'indexing' && $file != 'dbfastcache') {
                unlink($this->SqliteDir . '/' . $file);
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
            }
        }

        $db->exec('drop table if exists "balancing"');
        $db->exec('CREATE TABLE "balancing" ("keyword" VARCHAR PRIMARY KEY NOT NULL UNIQUE, "db" INTEGER)');
        $db->exec('CREATE INDEX "db" ON "balancing" ("db")');
        $db->exec('CREATE UNIQUE INDEX "lookup" ON "balancing" ("keyword")');

    }

    /**
     * INIT Instant DB
     * Return Database of Keyword
     * @param $keyword
     * @return int
     */
    public function indexing($keyword)
    {
        if ($this->indexing == null) {
            $createTable = false;
            if (!file_exists($this->SqliteDir . '/indexing')) {
                $createTable = true;
            }

            $PDO = new PDO("sqlite:" . $this->SqliteDir . '/' . self::INDEXING_FILE);
            $PDO->setAttribute(PDO::ATTR_ERRMODE,
              PDO::ERRMODE_EXCEPTION);

            if ($createTable == true) {

                $this->initIndexing($PDO);
            }
            $this->indexing = $PDO;

            unset($PDO);

            $stm = $this->indexing->prepare("SELECT MAX(`db`) as `db` FROM `balancing`");
            $stm->execute();
            $row = $stm->fetch(PDO::FETCH_ASSOC);
            if (!isset($row[ 'db' ])) {
                $db = 1;
            } elseif ($row[ 'db' ] <= 1) {
                $db = 1;
            } else {
                $db = $row[ 'db' ];
            }

            // check file size

            $size = file_exists($this->SqliteDir . '/db' . $db) ? filesize($this->SqliteDir . '/db' . $db) : 1;
            $size = round($size / 1024 / 1024, 1);


            if ($size > $this->maxSize) {
                $db++;
            }
            $this->currentDB = $db;

        }

        // look for keyword
        $stm = $this->indexing->prepare("SELECT * FROM `balancing` WHERE `keyword`=:keyword LIMIT 1");
        $stm->execute([
          ':keyword' => $keyword,
        ]);
        $row = $stm->fetch(PDO::FETCH_ASSOC);
        if (isset($row[ 'db' ]) && $row[ 'db' ] != '') {
            $db = $row[ 'db' ];
        } else {
            /*
             * Insert new to Indexing
             */
            $db = $this->currentDB;
            $stm = $this->indexing->prepare("INSERT INTO `balancing` (`keyword`,`db`) VALUES(:keyword, :db)");
            $stm->execute([
              ':keyword' => $keyword,
              ':db' => $db,
            ]);
        }

        return $db;
    }

    /**
     * @param $keyword
     * @param bool $reset
     * @return PDO
     */
    public function getDb($keyword, $reset = false)
    {
        /**
         * Default is fastcache
         */
        $instant = $this->indexing($keyword);

        /**
         * init instant
         */
        if (!isset($this->instance[ $instant ])) {
            // check DB Files ready or not
            $createTable = false;
            if (!file_exists($this->SqliteDir . '/db' . $instant) || $reset == true) {

                $createTable = true;
            }
            $PDO = new PDO('sqlite:' . $this->SqliteDir . '/db' . $instant);
            $PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

            if ($createTable == true) {

                $this->initDB($PDO);
            }

            $this->instance[ $instant ] = $PDO;
            unset($PDO);

        }

        return $this->instance[ $instant ];
    }

    /**
     * @param \Psr\Cache\CacheItemInterface $item
     * @return mixed
     * @throws \InvalidArgumentException
     */
    protected function driverWrite(CacheItemInterface $item)
    {
        /**
         * Check for Cross-Driver type confusion
         */
        if ($item instanceof Item) {
            $skipExisting = isset($this->config[ 'skipExisting' ]) ? $this->config[ 'skipExisting' ] : false;
            $toWrite = true;

            // check in cache first
            $in_cache = $this->driverRead($item);

            if ($skipExisting == true) {
                if ($in_cache == null) {
                    $toWrite = true;
                } else {
                    $toWrite = false;
                }
            }

            if ($toWrite == true) {

                try {
                    $stm = $this->getDb($item->getKey())
                      ->prepare("INSERT OR REPLACE INTO `caching` (`keyword`,`object`,`exp`) values(:keyword,:object,:exp)");
                    $stm->execute([
                      ':keyword' => $item->getKey(),
                      ':object' => $this->encode($this->driverPreWrap($item)),
                      ':exp' => time() + $item->getTtl(),
                    ]);

                    return true;
                } catch (\PDOException $e) {

                    try {
                        $stm = $this->getDb($item->getKey(), true)
                          ->prepare("INSERT OR REPLACE INTO `caching` (`keyword`,`object`,`exp`) values(:keyword,:object,:exp)");
                        $stm->execute([
                          ':keyword' => $item->getKey(),
                          ':object' => $this->encode($this->driverPreWrap($item)),
                          ':exp' => time() + $item->getTtl(),
                        ]);
                    } catch (PDOException $e) {
                        return false;
                    }
                }
            }

            return false;
        } else {
            throw new \InvalidArgumentException('Cross-Driver type confusion detected');
        }
    }

    /**
     * @param \Psr\Cache\CacheItemInterface $item
     * @return mixed
     */
    protected function driverRead(CacheItemInterface $item)
    {
        try {
            $stm = $this->getDb($item->getKey())
              ->prepare("SELECT * FROM `caching` WHERE `keyword`=:keyword AND (`exp` >= :U)  LIMIT 1");
            $stm->execute([
              ':keyword' => $item->getKey(),
              ':U' => time(),
            ]);
            $row = $stm->fetch(PDO::FETCH_ASSOC);

        } catch (PDOException $e) {
            try {
                $stm = $this->getDb($item->getKey(), true)
                  ->prepare("SELECT * FROM `caching` WHERE `keyword`=:keyword AND (`exp` >= :U)  LIMIT 1");
                $stm->execute([
                  ':keyword' => $item->getKey(),
                  ':U' => time(),
                ]);
                $row = $stm->fetch(PDO::FETCH_ASSOC);
            } catch (PDOException $e) {
                return null;
            }
        }

        if (isset($row[ 'id' ])) {
            /**
             * @var $item ExtendedCacheItemInterface
             */
            $item = $this->decode($row[ 'object' ]);
            if ($item instanceof ExtendedCacheItemInterface && $item->isExpired()) {
                $this->driverDelete($item);

                return null;
            }

            return $this->decode($row[ 'object' ]);
        }

        return null;
    }

    /**
     * @param \Psr\Cache\CacheItemInterface $item
     * @return bool
     * @throws \InvalidArgumentException
     */
    protected function driverDelete(CacheItemInterface $item)
    {
        /**
         * Check for Cross-Driver type confusion
         */
        if ($item instanceof Item) {
            try {
                $stm = $this->getDb($item->getKey())
                  //->prepare("DELETE FROM `caching` WHERE (`id`=:id) OR (`exp` <= :U) ");

                  ->prepare("DELETE FROM `caching` WHERE (`exp` <= :U) OR (`keyword`=:keyword) ");

                return $stm->execute([
                    // ':id' => $row[ 'id' ],

                  ':keyword' => $item->getKey(),
                  ':U' => time(),
                ]);
            } catch (PDOException $e) {
                return false;
            }
        } else {
            throw new \InvalidArgumentException('Cross-Driver type confusion detected');
        }
    }

    /**
     * @return bool
     */
    protected function driverClear()
    {
        $this->instance = [];
        $this->instance = null;

        // delete everything before reset indexing
        $dir = opendir($this->getSqliteDir());
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
        while ($file = readdir($dir)) {
            if ($file != '.' && $file != '..') {
                unlink($this->getSqliteDir() . '/' . $file);
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
            }
        }

        return true;
    }

    /**
     * @return bool
     */
    protected function driverConnect()
    {
        if (!file_exists($this->getPath() . '/' . self::FILE_DIR)) {
            if (!mkdir($this->getPath() . '/' . self::FILE_DIR, $this->setChmodAuto(), true)
if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) {
    throw new \InvalidArgumentException('This input is not allowed.');
}
            ) {
                $this->fallback = true;
            }
        }
        $this->SqliteDir = $this->getPath() . '/' . self::FILE_DIR;
    }

    /********************
     *
     * PSR-6 Extended Methods
     *
     *******************/

    /**
     * @return driverStatistic
     * @throws PDOException
     */
    public function getStats()

    {
        $stat = new driverStatistic();
        $path = $this->getFilePath(false);

        if (!is_dir($path)) {
            throw new phpFastCacheDriverException("Can't read PATH:" . $path, 94);
        }

        $stat->setData(implode(', ', array_keys($this->itemInstances)))
          ->setRawData([])
          ->setSize(Directory::dirSize($path))
          ->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));

        return $stat;
    }

    /**
     * @return array
     */
    public function __sleep()
    {
        return array_diff(array_keys(get_object_vars($this)), ['indexing', 'instance']);
    }
}

Branch — final (ad8b8d)

Driver::driverCheck() A

Complexity

Size

Duplication

Importance

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

1		<?php
2		/**
3		*
4		* This file is part of phpFastCache.
5		*
6		* @license MIT License (MIT)
7		*
8		* For full copyright and license information, please see the docs/CREDITS.txt file.
9		*
10		* @author Khoa Bui (khoaofgod) <[email protected]> http://www.phpfastcache.com
11		* @author Georges.L (Geolim4) <[email protected]>
12		*
13		*/
14
15		namespace phpFastCache\Drivers\Sqlite;
16
17		use PDO;
18		use PDOException;
19		use phpFastCache\Cache\ExtendedCacheItemInterface;
20		use phpFastCache\Core\DriverAbstract;
21		use phpFastCache\Core\PathSeekerTrait;
22		use phpFastCache\Core\StandardPsr6StructureTrait;
23		use phpFastCache\Entities\driverStatistic;
24		use phpFastCache\Exceptions\phpFastCacheDriverCheckException;
25		use phpFastCache\Exceptions\phpFastCacheDriverException;
26		use phpFastCache\Util\Directory;
27		use Psr\Cache\CacheItemInterface;
28
29		/**
30		* Class Driver
31		* @package phpFastCache\Drivers
32		*/
33		class Driver extends DriverAbstract
34		{
35		use PathSeekerTrait;
36
37		/**
38		*
39		*/
40		const FILE_DIR = 'sqlite';
41		/**
42		*
43		*/
44		const INDEXING_FILE = 'indexing';
45
46		/**
47		* @var int
48		*/
49		protected $maxSize = 10; // 10 mb
50
51		/**
52		* @var int
53		*/
54		protected $currentDB = 1;
55
56		/**
57		* @var string
58		*/
59		protected $SqliteDir = '';
60
61		/**
62		* @var null
63		*/
64		protected $indexing;
65
66		/**
67		* Driver constructor.
68		* @param array $config
69		* @throws phpFastCacheDriverException
70		*/
71		public function __construct(array $config = [])
72		{
73		$this->setup($config);
74
75		if (!$this->driverCheck()) {
76		throw new phpFastCacheDriverCheckException(sprintf(self::DRIVER_CHECK_FAILURE, $this->getDriverName()));
77		} else {
78		if (!file_exists($this->getSqliteDir()) && !@mkdir($this->getSqliteDir(), $this->setChmodAuto(), true)) {
		0 ignored issues – show Security File Manipulation introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->getSqliteDir()` can contain request data and is used in file manipulation context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
79		throw new phpFastCacheDriverException(sprintf('Sqlite cannot write in "%s", aborting...', $this->getPath()));
80		} else {
81		$this->driverConnect();
82		}
83		}
84		}
85
86		/**
87		* @return string
88		* @throws \phpFastCache\Exceptions\phpFastCacheCoreException
89		*/
90		public function getSqliteDir()
91		{
92		return $this->SqliteDir ?: $this->getPath() . DIRECTORY_SEPARATOR . self::FILE_DIR;
93		}
94
95		/**
96		* @return bool
97		*/
98		public function driverCheck()
99		{
100		return extension_loaded('pdo_sqlite') && (is_writable($this->getSqliteDir()) \|\| @mkdir($this->getSqliteDir(), $this->setChmodAuto(), true));
		0 ignored issues – show Security File Manipulation introduced 2016-05-25 19:26 UTC by Report Bug Copy Issue Report `$this->getSqliteDir()` can contain request data and is used in file manipulation context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
101		}
102
103		/**
104		* INIT NEW DB
105		* @param \PDO $db
106		*/
107		public function initDB(\PDO $db)
108		{
109		$db->exec('drop table if exists "caching"');
110		$db->exec('CREATE TABLE "caching" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "keyword" VARCHAR UNIQUE, "object" BLOB, "exp" INTEGER)');
111		$db->exec('CREATE UNIQUE INDEX "cleanup" ON "caching" ("keyword","exp")');
112		$db->exec('CREATE INDEX "exp" ON "caching" ("exp")');
113		$db->exec('CREATE UNIQUE INDEX "keyword" ON "caching" ("keyword")');
114		}
115
116		/**
117		* INIT Indexing DB
118		* @param \PDO $db
119		*/
120		public function initIndexing(\PDO $db)
121		{
122
123		// delete everything before reset indexing
124		$dir = opendir($this->SqliteDir);
		0 ignored issues – show Security File Exposure introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->SqliteDir` can contain request data and is used in file inclusion context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
125		while ($file = readdir($dir)) {
126		if ($file != '.' && $file != '..' && $file != 'indexing' && $file != 'dbfastcache') {
127		unlink($this->SqliteDir . '/' . $file);
		0 ignored issues – show Security File Manipulation introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->SqliteDir . '/' . $file` can contain request data and is used in file manipulation context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
128		}
129		}
130
131		$db->exec('drop table if exists "balancing"');
132		$db->exec('CREATE TABLE "balancing" ("keyword" VARCHAR PRIMARY KEY NOT NULL UNIQUE, "db" INTEGER)');
133		$db->exec('CREATE INDEX "db" ON "balancing" ("db")');
134		$db->exec('CREATE UNIQUE INDEX "lookup" ON "balancing" ("keyword")');
135
136		}
137
138		/**
139		* INIT Instant DB
140		* Return Database of Keyword
141		* @param $keyword
142		* @return int
143		*/
144		public function indexing($keyword)
145		{
146		if ($this->indexing == null) {
147		$createTable = false;
148		if (!file_exists($this->SqliteDir . '/indexing')) {
149		$createTable = true;
150		}
151
152		$PDO = new PDO("sqlite:" . $this->SqliteDir . '/' . self::INDEXING_FILE);
153		$PDO->setAttribute(PDO::ATTR_ERRMODE,
154		PDO::ERRMODE_EXCEPTION);
155
156		if ($createTable == true) {
		0 ignored issues – show Coding Style Best Practice introduced 2016-05-12 20:26 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
157		$this->initIndexing($PDO);
158		}
159		$this->indexing = $PDO;
		0 ignored issues – show Documentation Bug introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report It seems like `$PDO` of type `object<PDO>` is incompatible with the declared type `null` of property `$indexing`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
160		unset($PDO);
161
162		$stm = $this->indexing->prepare("SELECT MAX(`db`) as `db` FROM `balancing`");
163		$stm->execute();
164		$row = $stm->fetch(PDO::FETCH_ASSOC);
165		if (!isset($row[ 'db' ])) {
166		$db = 1;
167		} elseif ($row[ 'db' ] <= 1) {
168		$db = 1;
169		} else {
170		$db = $row[ 'db' ];
171		}
172
173		// check file size
174
175		$size = file_exists($this->SqliteDir . '/db' . $db) ? filesize($this->SqliteDir . '/db' . $db) : 1;
176		$size = round($size / 1024 / 1024, 1);
177
178
179		if ($size > $this->maxSize) {
180		$db++;
181		}
182		$this->currentDB = $db;
183
184		}
185
186		// look for keyword
187		$stm = $this->indexing->prepare("SELECT * FROM `balancing` WHERE `keyword`=:keyword LIMIT 1");
188		$stm->execute([
189		':keyword' => $keyword,
190		]);
191		$row = $stm->fetch(PDO::FETCH_ASSOC);
192		if (isset($row[ 'db' ]) && $row[ 'db' ] != '') {
193		$db = $row[ 'db' ];
194		} else {
195		/*
196		* Insert new to Indexing
197		*/
198		$db = $this->currentDB;
199		$stm = $this->indexing->prepare("INSERT INTO `balancing` (`keyword`,`db`) VALUES(:keyword, :db)");
200		$stm->execute([
201		':keyword' => $keyword,
202		':db' => $db,
203		]);
204		}
205
206		return $db;
207		}
208
209		/**
210		* @param $keyword
211		* @param bool $reset
212		* @return PDO
213		*/
214		public function getDb($keyword, $reset = false)
215		{
216		/**
217		* Default is fastcache
218		*/
219		$instant = $this->indexing($keyword);
220
221		/**
222		* init instant
223		*/
224		if (!isset($this->instance[ $instant ])) {
225		// check DB Files ready or not
226		$createTable = false;
227		if (!file_exists($this->SqliteDir . '/db' . $instant) \|\| $reset == true) {
		0 ignored issues – show Coding Style Best Practice introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
228		$createTable = true;
229		}
230		$PDO = new PDO('sqlite:' . $this->SqliteDir . '/db' . $instant);
231		$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
232
233		if ($createTable == true) {
		0 ignored issues – show Coding Style Best Practice introduced 2016-05-12 20:26 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
234		$this->initDB($PDO);
235		}
236
237		$this->instance[ $instant ] = $PDO;
238		unset($PDO);
239
240		}
241
242		return $this->instance[ $instant ];
243		}
244
245		/**
246		* @param \Psr\Cache\CacheItemInterface $item
247		* @return mixed
248		* @throws \InvalidArgumentException
249		*/
250		protected function driverWrite(CacheItemInterface $item)
251		{
252		/**
253		* Check for Cross-Driver type confusion
254		*/
255		if ($item instanceof Item) {
256		$skipExisting = isset($this->config[ 'skipExisting' ]) ? $this->config[ 'skipExisting' ] : false;
257		$toWrite = true;
258
259		// check in cache first
260		$in_cache = $this->driverRead($item);
261
262		if ($skipExisting == true) {
263		if ($in_cache == null) {
264		$toWrite = true;
265		} else {
266		$toWrite = false;
267		}
268		}
269
270		if ($toWrite == true) {
		0 ignored issues – show Coding Style Best Practice introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
271		try {
272		$stm = $this->getDb($item->getKey())
273		->prepare("INSERT OR REPLACE INTO `caching` (`keyword`,`object`,`exp`) values(:keyword,:object,:exp)");
274		$stm->execute([
275		':keyword' => $item->getKey(),
276		':object' => $this->encode($this->driverPreWrap($item)),
277		':exp' => time() + $item->getTtl(),
278		]);
279
280		return true;
281		} catch (\PDOException $e) {
282
283		try {
284		$stm = $this->getDb($item->getKey(), true)
285		->prepare("INSERT OR REPLACE INTO `caching` (`keyword`,`object`,`exp`) values(:keyword,:object,:exp)");
286		$stm->execute([
287		':keyword' => $item->getKey(),
288		':object' => $this->encode($this->driverPreWrap($item)),
289		':exp' => time() + $item->getTtl(),
290		]);
291		} catch (PDOException $e) {
292		return false;
293		}
294		}
295		}
296
297		return false;
298		} else {
299		throw new \InvalidArgumentException('Cross-Driver type confusion detected');
300		}
301		}
302
303		/**
304		* @param \Psr\Cache\CacheItemInterface $item
305		* @return mixed
306		*/
307		protected function driverRead(CacheItemInterface $item)
308		{
309		try {
310		$stm = $this->getDb($item->getKey())
311		->prepare("SELECT * FROM `caching` WHERE `keyword`=:keyword AND (`exp` >= :U) LIMIT 1");
312		$stm->execute([
313		':keyword' => $item->getKey(),
314		':U' => time(),
315		]);
316		$row = $stm->fetch(PDO::FETCH_ASSOC);
317
318		} catch (PDOException $e) {
319		try {
320		$stm = $this->getDb($item->getKey(), true)
321		->prepare("SELECT * FROM `caching` WHERE `keyword`=:keyword AND (`exp` >= :U) LIMIT 1");
322		$stm->execute([
323		':keyword' => $item->getKey(),
324		':U' => time(),
325		]);
326		$row = $stm->fetch(PDO::FETCH_ASSOC);
327		} catch (PDOException $e) {
328		return null;
329		}
330		}
331
332		if (isset($row[ 'id' ])) {
333		/**
334		* @var $item ExtendedCacheItemInterface
335		*/
336		$item = $this->decode($row[ 'object' ]);
337		if ($item instanceof ExtendedCacheItemInterface && $item->isExpired()) {
338		$this->driverDelete($item);
339
340		return null;
341		}
342
343		return $this->decode($row[ 'object' ]);
344		}
345
346		return null;
347		}
348
349		/**
350		* @param \Psr\Cache\CacheItemInterface $item
351		* @return bool
352		* @throws \InvalidArgumentException
353		*/
354		protected function driverDelete(CacheItemInterface $item)
355		{
356		/**
357		* Check for Cross-Driver type confusion
358		*/
359		if ($item instanceof Item) {
360		try {
361		$stm = $this->getDb($item->getKey())
362		//->prepare("DELETE FROM `caching` WHERE (`id`=:id) OR (`exp` <= :U) ");
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report `84%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
363		->prepare("DELETE FROM `caching` WHERE (`exp` <= :U) OR (`keyword`=:keyword) ");
364
365		return $stm->execute([
366		// ':id' => $row[ 'id' ],
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report `59%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
367		':keyword' => $item->getKey(),
368		':U' => time(),
369		]);
370		} catch (PDOException $e) {
371		return false;
372		}
373		} else {
374		throw new \InvalidArgumentException('Cross-Driver type confusion detected');
375		}
376		}
377
378		/**
379		* @return bool
380		*/
381		protected function driverClear()
382		{
383		$this->instance = [];
384		$this->instance = null;
385
386		// delete everything before reset indexing
387		$dir = opendir($this->getSqliteDir());
		0 ignored issues – show Security File Exposure introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->getSqliteDir()` can contain request data and is used in file inclusion context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
388		while ($file = readdir($dir)) {
389		if ($file != '.' && $file != '..') {
390		unlink($this->getSqliteDir() . '/' . $file);
		0 ignored issues – show Security File Manipulation introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->getSqliteDir() . '/' . $file` can contain request data and is used in file manipulation context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
391		}
392		}
393
394		return true;
395		}
396
397		/**
398		* @return bool
399		*/
400		protected function driverConnect()
401		{
402		if (!file_exists($this->getPath() . '/' . self::FILE_DIR)) {
403		if (!mkdir($this->getPath() . '/' . self::FILE_DIR, $this->setChmodAuto(), true)
		0 ignored issues – show Security File Manipulation introduced 2016-05-17 22:25 UTC by Report Bug Copy Issue Report `$this->getPath() . '/' . self::FILE_DIR` can contain request data and is used in file manipulation context(s) leading to a potential security vulnerability. General Strategies to prevent injection In general, it is advisable to prevent any user-data to reach this point. This can be done by white-listing certain values: if ( ! in_array($value, array('this-is-allowed', 'and-this-too'), true)) { throw new \InvalidArgumentException('This input is not allowed.'); } For numeric data, we recommend to explicitly cast the data: $sanitized = (integer) $tainted; Loading history...
404		) {
405		$this->fallback = true;
406		}
407		}
408		$this->SqliteDir = $this->getPath() . '/' . self::FILE_DIR;
409		}
410
411		/********************
412		*
413		* PSR-6 Extended Methods
414		*
415		*******************/
416
417		/**
418		* @return driverStatistic
419		* @throws PDOException
420		*/
421	View Code Duplication	public function getStats()
		1 ignored issue – show Duplication introduced 2016-05-16 02:40 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
422		{
423		$stat = new driverStatistic();
424		$path = $this->getFilePath(false);
425
426		if (!is_dir($path)) {
427		throw new phpFastCacheDriverException("Can't read PATH:" . $path, 94);
428		}
429
430		$stat->setData(implode(', ', array_keys($this->itemInstances)))
431		->setRawData([])
432		->setSize(Directory::dirSize($path))
433		->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));
434
435		return $stat;
436		}
437
438		/**
439		* @return array
440		*/
441		public function __sleep()
442		{
443		return array_diff(array_keys(get_object_vars($this)), ['indexing', 'instance']);
444		}
445		}

PHPSocialNetwork / phpfastcache

Branch — final (ad8b8d)

Driver::driverCheck() A

Complexity

Size

Duplication

Importance

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

General Strategies to prevent injection

Duplication Side-by-Side

Filter issues like