Jenner\SimpleFork\Lock\Semaphore

Complexity

Total Complexity

18

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

90.24%

Importance

Changes	5
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	4	1
A	__construct()	0	6	2
A	__destruct()	0	6	2
A	release()	0	13	3
A	isLocked()	0	4	2
A	_stringToSemKey()	0	9	2
B	acquire()	0	25	6

<?php
/**
 * Created by PhpStorm.
 * User: Jenner
 * Date: 2015/8/12
 * Time: 20:52
 */

namespace Jenner\SimpleFork\Lock;

There must be one blank line after the namespace declaration

class Semaphore implements LockInterface
{
    /**
     * create a lock instance
     *
     * @param $key
     * @return Semaphore
     */
    public static function create($key)
    {
        return new Semaphore($key);
    }

    /**
     * @var
     */
    private $lock_id;

    /**
     * @var bool
     */
    private $locked = false;

    /**
     * init a lock
     *
     * @param $key
     * @throws \RuntimeException
     */
    private function __construct($key)
    {
        if (($this->lock_id = sem_get($this->_stringToSemKey($key))) === false) {
            throw new \RuntimeException('Cannot create semaphore for key: ' . $key);
        }
    }

    /**
     * release lock
     *
     * @throws \RuntimeException
     */
    public function __destruct()
    {
        if ($this->isLocked()) {
            $this->release();
        }
    }


    /**
     * get a lock
     *
     * @param bool $blocking
     * @return bool
     */
    public function acquire($blocking = true)
    {
        if ($this->locked) {
            throw new \RuntimeException("already lock by yourself");
        }

        if ($blocking === false) {
            if (version_compare(PHP_VERSION, '5.6.0') < 0) {
                throw new \RuntimeException("php version is at least 5.6.0 for param blocking");
            }
            if (!sem_acquire($this->lock_id, true)) {
                return false;
            }
            $this->locked = true;

            return true;
        }

        if (!sem_acquire($this->lock_id)) {
            return false;
        }
        $this->locked = true;

        return true;
    }

    /**
     * release lock
     *
     * @return bool
     * @throws \RuntimeException
     */
    public function release()
    {
        if (!$this->locked) {
            throw new \RuntimeException("release a non lock");
        }

        if (!sem_release($this->lock_id)) {
            return false;
        }
        $this->locked = false;

        return true;
    }

    /**
     * is locked
     *
     * @return bool
     */
    public function isLocked()
    {
        return $this->locked === true ? true : false;
    }

    /**
     * Semaphore requires a numeric value as the key
     *
     * @param $identifier
     * @return int
     */
    protected function _stringToSemKey($identifier)

Method name "_stringToSemKey" should not be prefixed with an underscore to indicate visibility

    {
        $md5 = md5($identifier);
        $key = 0;
        for ($i = 0; $i < 32; $i++) {
            $key += ord($md5{$i}) * $i;
        }
        return $key;
    }
}