Code Coverage |
||||||||||
Lines |
Functions and Methods |
Classes and Traits |
||||||||
| Total | |
82.17% |
129 / 157 |
|
55.56% |
10 / 18 |
CRAP | |
0.00% |
0 / 1 |
| FilesCache | |
82.17% |
129 / 157 |
|
55.56% |
10 / 18 |
82.11 | |
0.00% |
0 / 1 |
| __destruct | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
2 | |||
| initialize | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| setGC | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
3 | |||
| setBaseDirectory | |
83.33% |
15 / 18 |
|
0.00% |
0 / 1 |
6.17 | |||
| get | |
100.00% |
8 / 8 |
|
100.00% |
1 / 1 |
2 | |||
| getContents | |
81.82% |
9 / 11 |
|
0.00% |
0 / 1 |
5.15 | |||
| createSubDirectory | |
57.14% |
4 / 7 |
|
0.00% |
0 / 1 |
5.26 | |||
| set | |
100.00% |
10 / 10 |
|
100.00% |
1 / 1 |
2 | |||
| setValue | |
86.67% |
13 / 15 |
|
0.00% |
0 / 1 |
4.04 | |||
| delete | |
100.00% |
8 / 8 |
|
100.00% |
1 / 1 |
2 | |||
| flush | |
100.00% |
7 / 7 |
|
100.00% |
1 / 1 |
2 | |||
| gc | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| deleteExpired | |
75.00% |
15 / 20 |
|
0.00% |
0 / 1 |
9.00 | |||
| deleteAll | |
65.22% |
15 / 23 |
|
0.00% |
0 / 1 |
12.41 | |||
| deleteFile | |
66.67% |
4 / 6 |
|
0.00% |
0 / 1 |
3.33 | |||
| openDir | |
66.67% |
6 / 9 |
|
0.00% |
0 / 1 |
4.59 | |||
| closeDir | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
2 | |||
| renderFilepath | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
1 | |||
| 1 | <?php declare(strict_types=1); |
| 2 | /* |
| 3 | * This file is part of Aplus Framework Cache Library. |
| 4 | * |
| 5 | * (c) Natan Felles <natanfelles@gmail.com> |
| 6 | * |
| 7 | * For the full copyright and license information, please view the LICENSE |
| 8 | * file that was distributed with this source code. |
| 9 | */ |
| 10 | namespace Framework\Cache; |
| 11 | |
| 12 | use InvalidArgumentException; |
| 13 | use JetBrains\PhpStorm\Pure; |
| 14 | use RuntimeException; |
| 15 | |
| 16 | /** |
| 17 | * Class FilesCache. |
| 18 | * |
| 19 | * @package cache |
| 20 | */ |
| 21 | class FilesCache extends Cache |
| 22 | { |
| 23 | /** |
| 24 | * Files Cache handler configurations. |
| 25 | * |
| 26 | * @var array<string,mixed> |
| 27 | */ |
| 28 | protected array $configs = [ |
| 29 | 'directory' => null, |
| 30 | 'files_permission' => 0644, |
| 31 | 'gc' => 1, |
| 32 | ]; |
| 33 | /** |
| 34 | * @var string|null |
| 35 | */ |
| 36 | protected ?string $baseDirectory; |
| 37 | |
| 38 | public function __destruct() |
| 39 | { |
| 40 | if (\rand(1, 100) <= $this->configs['gc']) { |
| 41 | $this->gc(); |
| 42 | } |
| 43 | } |
| 44 | |
| 45 | protected function initialize() : void |
| 46 | { |
| 47 | $this->setBaseDirectory(); |
| 48 | $this->setGC($this->configs['gc']); |
| 49 | } |
| 50 | |
| 51 | protected function setGC(int $gc) : void |
| 52 | { |
| 53 | if ($gc < 1 || $gc > 100) { |
| 54 | throw new InvalidArgumentException( |
| 55 | "Invalid cache GC: {$gc}" |
| 56 | ); |
| 57 | } |
| 58 | } |
| 59 | |
| 60 | protected function setBaseDirectory() : void |
| 61 | { |
| 62 | $path = $this->configs['directory']; |
| 63 | if ($path === null) { |
| 64 | $path = \sys_get_temp_dir(); |
| 65 | } |
| 66 | $real = \realpath($path); |
| 67 | if ($real === false) { |
| 68 | throw new RuntimeException("Invalid cache directory: {$path}"); |
| 69 | } |
| 70 | $real = \rtrim($path, \DIRECTORY_SEPARATOR) . \DIRECTORY_SEPARATOR; |
| 71 | if (isset($this->prefix[0])) { |
| 72 | $real .= $this->prefix; |
| 73 | } |
| 74 | if ( ! \is_dir($real)) { |
| 75 | throw new RuntimeException( |
| 76 | "Invalid cache directory path: {$real}" |
| 77 | ); |
| 78 | } |
| 79 | if ( ! \is_writable($real)) { |
| 80 | throw new RuntimeException( |
| 81 | "Cache directory is not writable: {$real}" |
| 82 | ); |
| 83 | } |
| 84 | $this->baseDirectory = $real . \DIRECTORY_SEPARATOR; |
| 85 | } |
| 86 | |
| 87 | public function get(string $key) : mixed |
| 88 | { |
| 89 | if (isset($this->debugCollector)) { |
| 90 | $start = \microtime(true); |
| 91 | return $this->addDebugGet( |
| 92 | $key, |
| 93 | $start, |
| 94 | $this->getContents($this->renderFilepath($key)) |
| 95 | ); |
| 96 | } |
| 97 | return $this->getContents($this->renderFilepath($key)); |
| 98 | } |
| 99 | |
| 100 | /** |
| 101 | * @param string $filepath |
| 102 | * |
| 103 | * @return mixed |
| 104 | */ |
| 105 | protected function getContents(string $filepath) : mixed |
| 106 | { |
| 107 | if ( ! \is_file($filepath)) { |
| 108 | return null; |
| 109 | } |
| 110 | $value = @\file_get_contents($filepath); |
| 111 | if ($value === false) { |
| 112 | $this->log("Cache (files): File '{$filepath}' could not be read"); |
| 113 | return null; |
| 114 | } |
| 115 | $value = (array) $this->unserialize($value); |
| 116 | if ( ! isset($value['ttl'], $value['data']) || $value['ttl'] <= \time()) { |
| 117 | $this->deleteFile($filepath); |
| 118 | return null; |
| 119 | } |
| 120 | return $value['data']; |
| 121 | } |
| 122 | |
| 123 | protected function createSubDirectory(string $filepath) : void |
| 124 | { |
| 125 | $dirname = \dirname($filepath); |
| 126 | if (\is_dir($dirname)) { |
| 127 | return; |
| 128 | } |
| 129 | if ( ! \mkdir($dirname, 0777, true) || ! \is_dir($dirname)) { |
| 130 | throw new RuntimeException( |
| 131 | "Directory key was not created: {$filepath}" |
| 132 | ); |
| 133 | } |
| 134 | } |
| 135 | |
| 136 | public function set(string $key, mixed $value, int $ttl = null) : bool |
| 137 | { |
| 138 | if (isset($this->debugCollector)) { |
| 139 | $start = \microtime(true); |
| 140 | return $this->addDebugSet( |
| 141 | $key, |
| 142 | $ttl, |
| 143 | $start, |
| 144 | $value, |
| 145 | $this->setValue($key, $value, $ttl) |
| 146 | ); |
| 147 | } |
| 148 | return $this->setValue($key, $value, $ttl); |
| 149 | } |
| 150 | |
| 151 | public function setValue(string $key, mixed $value, int $ttl = null) : bool |
| 152 | { |
| 153 | $filepath = $this->renderFilepath($key); |
| 154 | $this->createSubDirectory($filepath); |
| 155 | $value = [ |
| 156 | 'ttl' => \time() + $this->makeTtl($ttl), |
| 157 | 'data' => $value, |
| 158 | ]; |
| 159 | $value = $this->serialize($value); |
| 160 | $isFile = \is_file($filepath); |
| 161 | $written = @\file_put_contents($filepath, $value, \LOCK_EX); |
| 162 | if ($written !== false && $isFile === false) { |
| 163 | \chmod($filepath, $this->configs['files_permission']); |
| 164 | } |
| 165 | if ($written === false) { |
| 166 | $this->log("Cache (files): File '{$filepath}' could not be written"); |
| 167 | return false; |
| 168 | } |
| 169 | return true; |
| 170 | } |
| 171 | |
| 172 | public function delete(string $key) : bool |
| 173 | { |
| 174 | if (isset($this->debugCollector)) { |
| 175 | $start = \microtime(true); |
| 176 | return $this->addDebugDelete( |
| 177 | $key, |
| 178 | $start, |
| 179 | $this->deleteFile($this->renderFilepath($key)) |
| 180 | ); |
| 181 | } |
| 182 | return $this->deleteFile($this->renderFilepath($key)); |
| 183 | } |
| 184 | |
| 185 | public function flush() : bool |
| 186 | { |
| 187 | if (isset($this->debugCollector)) { |
| 188 | $start = \microtime(true); |
| 189 | return $this->addDebugFlush( |
| 190 | $start, |
| 191 | $this->deleteAll($this->baseDirectory) |
| 192 | ); |
| 193 | } |
| 194 | return $this->deleteAll($this->baseDirectory); |
| 195 | } |
| 196 | |
| 197 | /** |
| 198 | * Garbage collector. |
| 199 | * |
| 200 | * Deletes all expired items. |
| 201 | * |
| 202 | * @return bool TRUE if all expired items was deleted, FALSE if a fail occurs |
| 203 | */ |
| 204 | public function gc() : bool |
| 205 | { |
| 206 | return $this->deleteExpired($this->baseDirectory); |
| 207 | } |
| 208 | |
| 209 | protected function deleteExpired(string $baseDirectory) : bool |
| 210 | { |
| 211 | $handle = $this->openDir($baseDirectory); |
| 212 | if ($handle === false) { |
| 213 | return false; |
| 214 | } |
| 215 | $baseDirectory = \rtrim($baseDirectory, \DIRECTORY_SEPARATOR) . \DIRECTORY_SEPARATOR; |
| 216 | $status = true; |
| 217 | while (($path = \readdir($handle)) !== false) { |
| 218 | if ($path[0] === '.') { |
| 219 | continue; |
| 220 | } |
| 221 | $path = $baseDirectory . $path; |
| 222 | if (\is_file($path)) { |
| 223 | $this->getContents($path); |
| 224 | continue; |
| 225 | } |
| 226 | if ( ! $this->deleteExpired($path)) { |
| 227 | $status = false; |
| 228 | break; |
| 229 | } |
| 230 | if (\scandir($path, \SCANDIR_SORT_ASCENDING) === ['.', '..'] && ! \rmdir($path)) { |
| 231 | $status = false; |
| 232 | break; |
| 233 | } |
| 234 | } |
| 235 | $this->closeDir($handle); |
| 236 | return $status; |
| 237 | } |
| 238 | |
| 239 | protected function deleteAll(string $baseDirectory) : bool |
| 240 | { |
| 241 | $handle = $this->openDir($baseDirectory); |
| 242 | if ($handle === false) { |
| 243 | return false; |
| 244 | } |
| 245 | $baseDirectory = \rtrim($baseDirectory, \DIRECTORY_SEPARATOR) . \DIRECTORY_SEPARATOR; |
| 246 | $status = true; |
| 247 | while (($path = \readdir($handle)) !== false) { |
| 248 | if ($path[0] === '.') { |
| 249 | continue; |
| 250 | } |
| 251 | $path = $baseDirectory . $path; |
| 252 | if (\is_file($path)) { |
| 253 | if (\unlink($path)) { |
| 254 | continue; |
| 255 | } |
| 256 | $this->log("Cache (files): File '{$path}' could not be deleted"); |
| 257 | $status = false; |
| 258 | break; |
| 259 | } |
| 260 | if ( ! $this->deleteAll($path)) { |
| 261 | $status = false; |
| 262 | break; |
| 263 | } |
| 264 | if (\scandir($path, \SCANDIR_SORT_ASCENDING) === ['.', '..'] && ! \rmdir($path)) { |
| 265 | $status = false; |
| 266 | break; |
| 267 | } |
| 268 | } |
| 269 | $this->closeDir($handle); |
| 270 | return $status; |
| 271 | } |
| 272 | |
| 273 | protected function deleteFile(string $filepath) : bool |
| 274 | { |
| 275 | if (\is_file($filepath)) { |
| 276 | $deleted = \unlink($filepath); |
| 277 | if ($deleted === false) { |
| 278 | $this->log("Cache (files): File '{$filepath}' could not be deleted"); |
| 279 | return false; |
| 280 | } |
| 281 | } |
| 282 | return true; |
| 283 | } |
| 284 | |
| 285 | /** |
| 286 | * @param string $dirpath |
| 287 | * |
| 288 | * @return false|resource |
| 289 | */ |
| 290 | protected function openDir(string $dirpath) |
| 291 | { |
| 292 | $real = \realpath($dirpath); |
| 293 | if ($real === false) { |
| 294 | return false; |
| 295 | } |
| 296 | if ( ! \is_dir($real)) { |
| 297 | return false; |
| 298 | } |
| 299 | $real = \rtrim($real, \DIRECTORY_SEPARATOR) . \DIRECTORY_SEPARATOR; |
| 300 | if ( ! \str_starts_with($real, $this->configs['directory'])) { |
| 301 | return false; |
| 302 | } |
| 303 | return \opendir($real); |
| 304 | } |
| 305 | |
| 306 | /** |
| 307 | * @param resource $resource |
| 308 | */ |
| 309 | protected function closeDir($resource) : void |
| 310 | { |
| 311 | if (\is_resource($resource)) { |
| 312 | \closedir($resource); |
| 313 | } |
| 314 | } |
| 315 | |
| 316 | #[Pure] |
| 317 | protected function renderFilepath(string $key) : string |
| 318 | { |
| 319 | $key = \md5($key); |
| 320 | return $this->baseDirectory . |
| 321 | $key[0] . $key[1] . \DIRECTORY_SEPARATOR . |
| 322 | $key; |
| 323 | } |
| 324 | } |