Driver::peekQueue() - Code Metrics - bernardphp/bernard - Measure and Improve Code Quality continuously with Scrutinizer

Driver::peekQueue() A
last analyzed 2019-10-20 16:13 UTC

↳ Parent: Driver

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	2.0116

Importance

Changes

Metric	Value
dl	0
loc	20
ccs	12
cts	14
cp	0.8571
rs	9.6
c	0
b	0
f	0
cc	2
nc	2
nop	3
crap	2.0116

<?php

namespace Bernard\Driver\FlatFile;

/**
 * Flat file driver to provide a simple job queue without any
 * database.
 *
 * @author Markus Bachmann <[email protected]>
 */
class Driver implements \Bernard\Driver
{
    private $baseDirectory;

    private $permissions;

    /**
     * @param string $baseDirectory The base directory
     * @param int    $permissions   permissions to create the file with
     */
    public function __construct($baseDirectory, $permissions = 0740)
    {
        $this->baseDirectory = $baseDirectory;
        $this->permissions = $permissions;
    }

    /**
     * {@inheritdoc}
     */
    public function listQueues()
    {
        $it = new \FilesystemIterator($this->baseDirectory, \FilesystemIterator::SKIP_DOTS);

        $queues = [];

        foreach ($it as $file) {
            if (!$file->isDir()) {
                continue;
            }

            array_push($queues, $file->getBasename());
        }

        return $queues;
    }

    /**
     * {@inheritdoc}
     */
    public function createQueue($queueName)
    {
        $queueDir = $this->getQueueDirectory($queueName);

        if (is_dir($queueDir)) {
            return;
        }

        mkdir($queueDir, 0755, true);
    }

    /**
     * {@inheritdoc}
     */
    public function countMessages($queueName)
    {
        $iterator = new \RecursiveDirectoryIterator(
            $this->getQueueDirectory($queueName),
            \FilesystemIterator::SKIP_DOTS
        );
        $iterator = new \RecursiveIteratorIterator($iterator);
        $iterator = new \RegexIterator($iterator, '#\.job$#');

        return iterator_count($iterator);
    }

    /**
     * {@inheritdoc}
     */
    public function pushMessage($queueName, $message)
    {
        $queueDir = $this->getQueueDirectory($queueName);

        $filename = $this->getJobFilename($queueName);

        file_put_contents($queueDir.DIRECTORY_SEPARATOR.$filename, $message);
        chmod($queueDir.DIRECTORY_SEPARATOR.$filename, $this->permissions);
    }

    /**
     * {@inheritdoc}
     */
    public function popMessage($queueName, $duration = 5)
    {
        $runtime = microtime(true) + $duration;
        $queueDir = $this->getQueueDirectory($queueName);

        $files = $this->getJobFiles($queueName);

        while (microtime(true) < $runtime) {
            if ($files) {

                $id = array_pop($files);
                if (@rename($queueDir.DIRECTORY_SEPARATOR.$id, $queueDir.DIRECTORY_SEPARATOR.$id.'.proceed')) {
                    return [file_get_contents($queueDir.DIRECTORY_SEPARATOR.$id.'.proceed'), $id];
                }

                return $this->processFileOrFail($queueDir, $id);
            } else {
                // In order to notice that a new message received, update the list.
                $files = $this->getJobFiles($queueName);
            }

            usleep(1000);
        }

        return [null, null];
    }

    /**
     * @param string $queueDir
     * @param string $id
     * 
     * @return array
     */
    private function processFileOrFail($queueDir, $id) {
        $name = $queueDir.DIRECTORY_SEPARATOR.$id;
        $newName = $name.'.proceed';

        if (!@rename($name, $newName)) {
            throw new InsufficientPermissionsException('Unable to process file: '.$name);
        }

        return [file_get_contents($newName), $id];
    }

    /**
     * {@inheritdoc}
     */
    public function acknowledgeMessage($queueName, $receipt)
    {
        $queueDir = $this->getQueueDirectory($queueName);
        $path = $queueDir.DIRECTORY_SEPARATOR.$receipt.'.proceed';

        if (!is_file($path)) {
            return;
        }

        unlink($path);
    }

    /**
     * {@inheritdoc}
     */
    public function peekQueue($queueName, $index = 0, $limit = 20)
    {
        $queueDir = $this->getQueueDirectory($queueName);

        $it = new \GlobIterator($queueDir.DIRECTORY_SEPARATOR.'*.job', \FilesystemIterator::KEY_AS_FILENAME);
        $files = array_keys(iterator_to_array($it));

        natsort($files);
        $files = array_reverse($files);

        $files = array_slice($files, $index, $limit);

        $messages = [];

        foreach ($files as $file) {
            array_push($messages, file_get_contents($queueDir.DIRECTORY_SEPARATOR.$file));
        }

        return $messages;
    }

    /**
     * {@inheritdoc}
     */
    public function removeQueue($queueName)
    {
        $iterator = new \RecursiveDirectoryIterator(
            $this->getQueueDirectory($queueName),
            \FilesystemIterator::SKIP_DOTS
        );
        $iterator = new \RecursiveIteratorIterator($iterator);
        $iterator = new \RegexIterator($iterator, '#\.job(.proceed)?$#');

        foreach ($iterator as $file) {
            /* @var $file \DirectoryIterator */
            unlink($file->getRealPath());
        }

        rmdir($this->getQueueDirectory($queueName));
    }

    /**
     * {@inheritdoc}
     */
    public function info()
    {
        return [];
    }

    /**
     * @param string $queueName
     *
     * @return string
     */
    private function getQueueDirectory($queueName)
    {
        return $this->baseDirectory.DIRECTORY_SEPARATOR.str_replace(['\\', '.'], '-', $queueName);
    }

    /**
     * Generates a uuid.
     *
     * @param string $queueName
     *
     * @return string
     */
    private function getJobFilename($queueName)
    {
        $path = $this->baseDirectory.'/bernard.meta';

        if (!is_file($path)) {
            touch($path);
            chmod($path, $this->permissions);
        }

        $file = new \SplFileObject($path, 'r+');
        $file->flock(LOCK_EX);

        $meta = unserialize($file->fgets());

        $id = isset($meta[$queueName]) ? $meta[$queueName] : 0;
        ++$id;

        $filename = sprintf('%d.job', $id);
        $meta[$queueName] = $id;

        $content = serialize($meta);

        $file->fseek(0);
        $file->fwrite($content, strlen($content));
        $file->flock(LOCK_UN);

        return $filename;
    }

    /**
     * @param string $queueName
     *
     * @return string[]
     */
    private function getJobFiles($queueName)
    {
        $it = new \GlobIterator(
            $this->getQueueDirectory($queueName) . DIRECTORY_SEPARATOR . '*.job',
            \FilesystemIterator::KEY_AS_FILENAME
        );
        $files = array_keys(iterator_to_array($it));
        natsort($files);

        return $files;
    }
}


1		<?php
2
3		namespace Bernard\Driver\FlatFile;
4
5		/**
6		* Flat file driver to provide a simple job queue without any
7		* database.
8		*
9		* @author Markus Bachmann <[email protected]>
10		*/
11		class Driver implements \Bernard\Driver
12		{
13		private $baseDirectory;
14
15		private $permissions;
16
17		/**
18		* @param string $baseDirectory The base directory
19		* @param int $permissions permissions to create the file with
20		*/
21	10	public function __construct($baseDirectory, $permissions = 0740)
22		{
23	10	$this->baseDirectory = $baseDirectory;
24	10	$this->permissions = $permissions;
25	10	}
26
27		/**
28		* {@inheritdoc}
29		*/
30	1	public function listQueues()
31		{
32	1	$it = new \FilesystemIterator($this->baseDirectory, \FilesystemIterator::SKIP_DOTS);
33
34	1	$queues = [];
35
36	1	foreach ($it as $file) {
37	1	if (!$file->isDir()) {
38	1	continue;
39		}
40
41	1	array_push($queues, $file->getBasename());
42	1	}
43
44	1	return $queues;
45		}
46
47		/**
48		* {@inheritdoc}
49		*/
50	10	public function createQueue($queueName)
51		{
52	10	$queueDir = $this->getQueueDirectory($queueName);
53
54	10	if (is_dir($queueDir)) {
55	1	return;
56		}
57
58	10	mkdir($queueDir, 0755, true);
59	10	}
60
61		/**
62		* {@inheritdoc}
63		*/
64		public function countMessages($queueName)
65		{
66		$iterator = new \RecursiveDirectoryIterator(
67		$this->getQueueDirectory($queueName),
68		\FilesystemIterator::SKIP_DOTS
69		);
70		$iterator = new \RecursiveIteratorIterator($iterator);
71		$iterator = new \RegexIterator($iterator, '#\.job$#');
72
73		return iterator_count($iterator);
74		}
75
76		/**
77		* {@inheritdoc}
78		*/
79	8	public function pushMessage($queueName, $message)
80		{
81	8	$queueDir = $this->getQueueDirectory($queueName);
82
83	8	$filename = $this->getJobFilename($queueName);
84
85	8	file_put_contents($queueDir.DIRECTORY_SEPARATOR.$filename, $message);
86	8	chmod($queueDir.DIRECTORY_SEPARATOR.$filename, $this->permissions);
87	8	}
88
89		/**
90		* {@inheritdoc}
91		*/
92	4	public function popMessage($queueName, $duration = 5)
93		{
94	4	$runtime = microtime(true) + $duration;
95	4	$queueDir = $this->getQueueDirectory($queueName);
96
97	4	$files = $this->getJobFiles($queueName);
98
99	4	while (microtime(true) < $runtime) {
100	4	if ($files) {
		0 ignored issues – show Bug Best Practice introduced 2018-08-15 06:55 UTC by Report Bug Copy Issue Report The expression `$files` of type `string[]` 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 check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
101	4	$id = array_pop($files);
102	4	if (@rename($queueDir.DIRECTORY_SEPARATOR.$id, $queueDir.DIRECTORY_SEPARATOR.$id.'.proceed')) {
103	4	return [file_get_contents($queueDir.DIRECTORY_SEPARATOR.$id.'.proceed'), $id];
104		}
105
106		return $this->processFileOrFail($queueDir, $id);
107		} else {
108		// In order to notice that a new message received, update the list.
109	1	$files = $this->getJobFiles($queueName);
110		}
111
112	1	usleep(1000);
113	1	}
114
115		return [null, null];
116		}
117
118		/**
119		* @param string $queueDir
120		* @param string $id
121		*
122		* @return array
123		*/
124		private function processFileOrFail($queueDir, $id) {
125		$name = $queueDir.DIRECTORY_SEPARATOR.$id;
126		$newName = $name.'.proceed';
127
128		if (!@rename($name, $newName)) {
129		throw new InsufficientPermissionsException('Unable to process file: '.$name);
130		}
131
132		return [file_get_contents($newName), $id];
133		}
134
135		/**
136		* {@inheritdoc}
137		*/
138	1	public function acknowledgeMessage($queueName, $receipt)
139		{
140	1	$queueDir = $this->getQueueDirectory($queueName);
141	1	$path = $queueDir.DIRECTORY_SEPARATOR.$receipt.'.proceed';
142
143	1	if (!is_file($path)) {
144		return;
145		}
146
147	1	unlink($path);
148	1	}
149
150		/**
151		* {@inheritdoc}
152		*/
153	1	public function peekQueue($queueName, $index = 0, $limit = 20)
154		{
155	1	$queueDir = $this->getQueueDirectory($queueName);
156
157	1	$it = new \GlobIterator($queueDir.DIRECTORY_SEPARATOR.'*.job', \FilesystemIterator::KEY_AS_FILENAME);
158	1	$files = array_keys(iterator_to_array($it));
159
160	1	natsort($files);
161	1	$files = array_reverse($files);
162
163	1	$files = array_slice($files, $index, $limit);
164
165	1	$messages = [];
166
167	1	foreach ($files as $file) {
168	1	array_push($messages, file_get_contents($queueDir.DIRECTORY_SEPARATOR.$file));
169	1	}
170
171	1	return $messages;
172		}
173
174		/**
175		* {@inheritdoc}
176		*/
177	2	public function removeQueue($queueName)
178		{
179	2	$iterator = new \RecursiveDirectoryIterator(
180	2	$this->getQueueDirectory($queueName),
181		\FilesystemIterator::SKIP_DOTS
182	2	);
183	2	$iterator = new \RecursiveIteratorIterator($iterator);
184	2	$iterator = new \RegexIterator($iterator, '#\.job(.proceed)?$#');
185
186	2	foreach ($iterator as $file) {
187		/* @var $file \DirectoryIterator */
188	2	unlink($file->getRealPath());
189	2	}
190
191	2	rmdir($this->getQueueDirectory($queueName));
192	2	}
193
194		/**
195		* {@inheritdoc}
196		*/
197		public function info()
198		{
199		return [];
200		}
201
202		/**
203		* @param string $queueName
204		*
205		* @return string
206		*/
207	10	private function getQueueDirectory($queueName)
208		{
209	10	return $this->baseDirectory.DIRECTORY_SEPARATOR.str_replace(['\\', '.'], '-', $queueName);
210		}
211
212		/**
213		* Generates a uuid.
214		*
215		* @param string $queueName
216		*
217		* @return string
218		*/
219	8	private function getJobFilename($queueName)
220		{
221	8	$path = $this->baseDirectory.'/bernard.meta';
222
223	8	if (!is_file($path)) {
224	8	touch($path);
225	8	chmod($path, $this->permissions);
226	8	}
227
228	8	$file = new \SplFileObject($path, 'r+');
229	8	$file->flock(LOCK_EX);
230
231	8	$meta = unserialize($file->fgets());
232
233	8	$id = isset($meta[$queueName]) ? $meta[$queueName] : 0;
234	8	++$id;
235
236	8	$filename = sprintf('%d.job', $id);
237	8	$meta[$queueName] = $id;
238
239	8	$content = serialize($meta);
240
241	8	$file->fseek(0);
242	8	$file->fwrite($content, strlen($content));
243	8	$file->flock(LOCK_UN);
244
245	8	return $filename;
246		}
247
248		/**
249		* @param string $queueName
250		*
251		* @return string[]
252		*/
253	4	private function getJobFiles($queueName)
254		{
255	4	$it = new \GlobIterator(
256	4	$this->getQueueDirectory($queueName) . DIRECTORY_SEPARATOR . '*.job',
257		\FilesystemIterator::KEY_AS_FILENAME
258	4	);
259	4	$files = array_keys(iterator_to_array($it));
260	4	natsort($files);
261
262	4	return $files;
263		}
264		}
265

bernardphp / bernard

GitHub Access Token became invalid

Driver::peekQueue() A last analyzed 2019-10-20 16:13 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Driver::peekQueue() A
last analyzed 2019-10-20 16:13 UTC