Initial commit

Author: Mathieu Rochette

Diff for: .gitignore

@@ -0,0 +1,2 @@
+composer.lock
+/vendor/

Diff for: .travis.yml

@@ -0,0 +1,13 @@
+language: php
+
+php:
+    - 5.4
+    - 5.5
+    - 5.6
+    - hhvm
+
+before_script:
+    - composer install -n
+
+script:
+    - vendor/bin/phpspec run -f pretty

Diff for: composer.json

@@ -0,0 +1,22 @@
+{
+    "name": "texthtml/php-lock",
+    "description" : "ressource lock",
+    "license": "aGPLv3",
+    "type": "library",
+    "autoload": {
+        "psr-4": { "TH\\Lock\\": "src" }
+    },
+    "authors": [
+        {
+            "name": "Mathieu Rochette",
+            "email": "[email protected]"
+        }
+    ],
+    "require-dev": {
+        "phpspec/phpspec": "~2.0",
+        "php-vfs/php-vfs": "~1.1"
+    },
+    "require": {
+        "psr/log": "~1.0"
+    }
+}

Diff for: spec/TH/Lock/FileFactorySpec.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace spec\TH\Lock;
+
+use VirtualFileSystem\FileSystem;
+use Psr\Log\LoggerInterface;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class FileFactorySpec extends ObjectBehavior
+{
+    private $fs;
+    private $lock_dir;
+
+    public function let(LoggerInterface $logger)
+    {
+        $this->fs = new FileSystem;
+        $this->lock_dir = $this->fs->path('/path/to/lock_dir');
+
+        $this->beConstructedWith($logger, $this->lock_dir, 'sha256');
+    }
+
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType('TH\Lock\FileFactory');
+        $this->shouldImplement('TH\Lock\LockFactory');
+    }
+
+    public function it_should_create_a_file_lock()
+    {
+        $this->create('some resource identifier')->shouldhaveType('TH\Lock\FileLock');
+    }
+}

Diff for: src/FileFactory.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace TH\Lock;
+
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+
+class FileFactory implements LockFactory
+{
+    private $lock_dir;
+    private $logger;
+    private $hash_algo;
+
+    public function __construct(LoggerInterface $logger, $lock_dir, $hash_algo = 'sha256')
+    {
+        $this->logger    = $logger;
+        $this->lock_dir  = $lock_dir;
+        $this->hash_algo = $hash_algo;
+    }
+
+    public function create($resource, $owner = null, $operation = LOCK_EX)
+    {
+        if (!is_dir($this->lock_dir)) {
+            mkdir($this->lock_dir, 0777, true);
+        }
+
+        $path = $this->lock_dir.'/'.hash($this->hash_algo, serialize($resource)).'.lock';
+
+        $lock = new FileLock($path, $resource, $owner, $operation);
+
+        $lock->setLogger($this->logger);
+
+        return $lock;
+    }
+}

Diff for: src/FileLock.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace TH\Lock;
+
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+use Exception;
+
+class FileLock implements Lock
+{
+    private $identifier;
+    private $lock_file;
+    private $owner;
+    private $operation;
+    private $fh;
+
+    public function __construct($lock_file, $identifier = null, $owner = null, $operation = LOCK_EX, $blocking = false)
+    {
+        $this->identifier = $identifier?:$lock_file;
+        $this->lock_file     = $lock_file;
+        $this->owner         = $owner === null ? '' : $owner.': ';
+        $this->operation     = $operation | LOCK_NB;
+
+        if ($blocking) {
+            $this->operation &= ~LOCK_NB;
+        }
+
+        $this->logger = new NullLogger;
+    }
+
+    public function acquire()
+    {
+        $blocking  = !$this->operation & LOCK_NB;
+        $exclusive = $this->operation & LOCK_EX;
+
+        if (!flock($this->fh(), $this->operation)) {
+            $this->logger->debug(($exclusive ?
+                '{owner} could not acquire exclusive lock on {identifier}':
+                '{owner} could not acquire shared lock on {identifier}'
+            ), [
+                'identifier' => $this->identifier,
+                'owner' => $this->owner
+            ]);
+
+            throw new Exception(
+                'Could not acquire exclusive lock on '.($this->identifier ? $this->identifier : $this->lock_file)
+            );
+
+        }
+
+        $this->logger->debug(($exclusive ?
+            '{owner} exclusive lock acquired on {identifier}':
+            '{owner} shared lock acquired on {identifier}'
+        ), [
+            'identifier' => $this->identifier,
+            'owner' => $this->owner
+        ]);
+
+        return true;
+    }
+
+    public function release()
+    {
+        if ($this->fh === null) {
+            return;
+        }
+
+        flock($this->fh, LOCK_UN);
+
+        $this->logger->debug(
+            '{owner} lock released on {identifier}',
+            [
+                'identifier' => $this->identifier,
+                'owner' => $this->owner
+            ]
+        );
+    }
+
+    public function setLogger(LoggerInterface $logger)
+    {
+        $this->logger = $logger;
+    }
+
+    public function __destruct()
+    {
+        $this->release();
+    }
+
+    private function fh()
+    {
+        if ($this->fh === null) {
+            $this->fh = fopen($this->lock_file, 'c');
+        }
+
+        return $this->fh;
+    }
+}

Diff for: src/Lock.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace TH\Lock;
+
+interface Lock
+{
+    public function acquire();
+    public function release();
+}

Diff for: src/LockFactory.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace TH\Lock;
+
+interface LockFactory
+{
+    public function create($resource, $owner = null);
+}