RedisLockStrategy::isAcquired() - Code Metrics - Inspection of "re-implementation with a REDIS list as a synchroni..." - tourstream/typo3-redis-lock-strategy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

unknown

created 2017-12-15 00:17 UTC

RedisLockStrategy::isAcquired() A

↳ Parent: RedisLockStrategy

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	4
ccs	0
cts	0
cp	0
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php

namespace Tourstream\RedisLockStrategy;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2017 Alexander Miehe ([email protected])
 *  All rights reserved
 *
 *  You may not remove or change the name of the author above. See:
 *  http://www.gnu.org/licenses/gpl-faq.html#IWantCredit
 *
 *  This script is part of the Typo3 project. The Typo3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *  A copy is found in the LICENSE and distributed with these scripts.
 *
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use TYPO3\CMS\Core\Locking\Exception\LockAcquireException;
use TYPO3\CMS\Core\Locking\Exception\LockCreateException;
use TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException;
use TYPO3\CMS\Core\Locking\LockingStrategyInterface;

/**
 * @author Alexander Miehe <[email protected]>
 */
class RedisLockStrategy implements LockingStrategyInterface
{
    /**
     * @var \Redis A key-value data store
     */
    private $redis;

    /**
     * @var string The locking subject, i.e. a string to discriminate the lock
     */
    private $subject;

    /**
     * @var boolean TRUE if lock is acquired
     */
    private $isAcquired = false;

    /**
     * @var int Seconds the lock remains persistent
     */
    private $ttl = 3600;

    /**
     * @var int Seconds to wait for a lock
     */
    private $blTo = 60;

    /**
     * @inheritdoc
     */
    public function __construct($subject)
    {
        $config = null;

        if (\array_key_exists('redis_lock', $GLOBALS['TYPO3_CONF_VARS']['SYS'])) {
            $config = $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'];
        }

        if (!\is_array($config)) {
            throw new LockCreateException('no configuration for redis lock strategy found');
        }

        if (!\array_key_exists('host', $config)) {
            throw new LockCreateException('no host for redis lock strategy found');
        }
        $port = 6379;

        if (\array_key_exists('port', $config)) {
            $port = (int) $config['port'];
        }

        if (!\array_key_exists('database', $config)) {
            throw new LockCreateException('no database for redis lock strategy found');
        }

        if (\array_key_exists('ttl', $config)) {
            $this->ttl = (int) $config['ttl'];
        }

        $this->subject = $subject;
        $this->redis   = new \Redis();
        $this->redis->connect($config['host'], $port);

        if (\array_key_exists('auth', $config)) {
            $this->redis->auth($config['auth']);
        }

        $this->redis->select((int) $config['database']);

        if (!$this->redis->exists($this->subject)) {
            $this->create();
        }
    }

    /**
     * @inheritdoc
     */
    public static function getCapabilities()
    {
        return self::LOCK_CAPABILITY_EXCLUSIVE | self::LOCK_CAPABILITY_NOBLOCK;
    }

    /**
     * @inheritdoc
     */
    public static function getPriority()
    {
        return 100;
    }

    /**
     * @inheritdoc
     */
    public function acquire($mode = self::LOCK_CAPABILITY_EXCLUSIVE)
    {
        if ($this->isAcquired) {
            return true;
        }

        if ($mode & self::LOCK_CAPABILITY_EXCLUSIVE) {

            if ($mode & self::LOCK_CAPABILITY_NOBLOCK) {

                // this does not block
                $this->isAcquired = (bool) $this->redis->lPop($this->subject);

                if (!$this->isAcquired) {
                    throw new LockAcquireWouldBlockException('could not acquire lock');
                }
            } else {

                // this blocks iff the list is empty
                $this->isAcquired = (bool) $this->redis->blPop([$this->subject], $this->blTo);

                if (!$this->isAcquired) {
                    throw new LockAcquireException('could not acquire lock');
                }
            }

        } else {
            throw new LockAcquireException('insufficient capabilities');
        }

        return true;
    }

    /**
     * @inheritdoc
     */
    public function isAcquired()
    {
        return $this->isAcquired;
    }

    /**
     * @inheritdoc
     */
    public function destroy()
    {
        $this->redis->del($this->subject);
    }

    /**
     * @inheritdoc
     */
    public function release()
    {
        if (!$this->isAcquired) {
            return true;
        }

        $this->isAcquired = !$this->create();

        return !$this->isAcquired;
    }

    /**
     * create synchronization object, i.e.
     * a simple list with some single random value
     *
     * @return boolean TRUE on success
     * @throws LockCreateException
     */
    private function create()
    {
        if (!$this->redis->rPush($this->subject, uniqid())) {
            throw new LockCreateException('could not create lock entry');
        }

        if (!$this->redis->expire($this->subject, $this->ttl)) {
            throw new LockCreateException('could not set ttl to lock entry');
        }

        return true;
    }

}


1		<?php
2
3		namespace Tourstream\RedisLockStrategy;
4
5		/***************************************************************
6		* Copyright notice
7		*
8		* (c) 2017 Alexander Miehe ([email protected])
9		* All rights reserved
10		*
11		* You may not remove or change the name of the author above. See:
12		* http://www.gnu.org/licenses/gpl-faq.html#IWantCredit
13		*
14		* This script is part of the Typo3 project. The Typo3 project is
15		* free software; you can redistribute it and/or modify
16		* it under the terms of the GNU General Public License as published by
17		* the Free Software Foundation; either version 3 of the License, or
18		* (at your option) any later version.
19		*
20		* The GNU General Public License can be found at
21		* http://www.gnu.org/copyleft/gpl.html.
22		* A copy is found in the LICENSE and distributed with these scripts.
23		*
24		*
25		* This script is distributed in the hope that it will be useful,
26		* but WITHOUT ANY WARRANTY; without even the implied warranty of
27		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28		* GNU General Public License for more details.
29		*
30		* This copyright notice MUST APPEAR in all copies of the script!
31		***************************************************************/
32
33		use TYPO3\CMS\Core\Locking\Exception\LockAcquireException;
34		use TYPO3\CMS\Core\Locking\Exception\LockCreateException;
35		use TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException;
36		use TYPO3\CMS\Core\Locking\LockingStrategyInterface;
37
38		/**
39		* @author Alexander Miehe <[email protected]>
40		*/
41		class RedisLockStrategy implements LockingStrategyInterface
42		{
43		/**
44		* @var \Redis A key-value data store
45		*/
46		private $redis;
47
48		/**
49		* @var string The locking subject, i.e. a string to discriminate the lock
50		*/
51		private $subject;
52
53		/**
54		* @var boolean TRUE if lock is acquired
55		*/
56		private $isAcquired = false;
57
58		/**
59	9	* @var int Seconds the lock remains persistent
60		*/
61	9	private $ttl = 3600;
62
63	9	/**
64	8	* @var int Seconds to wait for a lock
65		*/
66		private $blTo = 60;
67	9
68	2	/**
69		* @inheritdoc
70		*/
71	7	public function __construct($subject)
72	1	{
73		$config = null;
74	6
75		if (\array_key_exists('redis_lock', $GLOBALS['TYPO3_CONF_VARS']['SYS'])) {
76	6	$config = $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'];
77	5	}
78
79		if (!\is_array($config)) {
80	6	throw new LockCreateException('no configuration for redis lock strategy found');
81	1	}
82
83		if (!\array_key_exists('host', $config)) {
84	5	throw new LockCreateException('no host for redis lock strategy found');
85	5	}
86		$port = 6379;
87
88		if (\array_key_exists('port', $config)) {
89	5	$port = (int) $config['port'];
90	5	}
91	5
92		if (!\array_key_exists('database', $config)) {
93	5	throw new LockCreateException('no database for redis lock strategy found');
94		}
95
96		if (\array_key_exists('ttl', $config)) {
97	5	$this->ttl = (int) $config['ttl'];
98	5	}
99
100		$this->subject = $subject;
101		$this->redis = new \Redis();
102		$this->redis->connect($config['host'], $port);
103	9
104		if (\array_key_exists('auth', $config)) {
105	9	$this->redis->auth($config['auth']);
106		}
107
108		$this->redis->select((int) $config['database']);
109
110		if (!$this->redis->exists($this->subject)) {
111	9	$this->create();
112		}
113	9	}
114
115		/**
116		* @inheritdoc
117		*/
118		public static function getCapabilities()
119	2	{
120		return self::LOCK_CAPABILITY_EXCLUSIVE \| self::LOCK_CAPABILITY_NOBLOCK;
121	2	}
122	1
123		/**
124		* @inheritdoc
125	1	*/
126		public static function getPriority()
127		{
128		return 100;
129		}
130
131	5	/**
132		* @inheritdoc
133	5	*/
134		public function acquire($mode = self::LOCK_CAPABILITY_EXCLUSIVE)
135		{
136		if ($this->isAcquired) {
137		return true;
138		}
139	2
140		if ($mode & self::LOCK_CAPABILITY_EXCLUSIVE) {
141	2
142	2	if ($mode & self::LOCK_CAPABILITY_NOBLOCK) {
143
144		// this does not block
145		$this->isAcquired = (bool) $this->redis->lPop($this->subject);
146
147	2	if (!$this->isAcquired) {
148		throw new LockAcquireWouldBlockException('could not acquire lock');
149	2	}
150	1	} else {
151
152		// this blocks iff the list is empty
153	1	$this->isAcquired = (bool) $this->redis->blPop([$this->subject], $this->blTo);
154
155		if (!$this->isAcquired) {
156		throw new LockAcquireException('could not acquire lock');
157		}
158		}
159
160		} else {
161		throw new LockAcquireException('insufficient capabilities');
162		}
163
164		return true;
165		}
166
167		/**
168		* @inheritdoc
169		*/
170		public function isAcquired()
171		{
172		return $this->isAcquired;
173		}
174
175		/**
176		* @inheritdoc
177		*/
178		public function destroy()
179		{
180		$this->redis->del($this->subject);
181		}
182
183		/**
184		* @inheritdoc
185		*/
186		public function release()
187		{
188		if (!$this->isAcquired) {
189		return true;
190		}
191
192		$this->isAcquired = !$this->create();
193
194		return !$this->isAcquired;
195		}
196
197		/**
198		* create synchronization object, i.e.
199		* a simple list with some single random value
200		*
201		* @return boolean TRUE on success
202		* @throws LockCreateException
203		*/
204		private function create()
205		{
206		if (!$this->redis->rPush($this->subject, uniqid())) {
207		throw new LockCreateException('could not create lock entry');
208		}
209
210		if (!$this->redis->expire($this->subject, $this->ttl)) {
211		throw new LockCreateException('could not set ttl to lock entry');
212		}
213
214		return true;
215		}
216
217		}
218

tourstream / typo3-redis-lock-strategy

Pull Request — master (#8)

RedisLockStrategy::isAcquired() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like