redis session handler

Author: dmitry-suffi

.gitignore

@@ -0,0 +1,2 @@
+.idea
+

LICENSE

@@ -0,0 +1,20 @@
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

Readme.md

@@ -0,0 +1,33 @@
+Обработчик сессий через Redis с механизмом блокировки
+=====================================================
+
+
+Описание
+---------
+Используется для хранения сессий php в редисе.
+
+Добавлен механизм блокировок: пока один процесс работает с сессией, второй процесс ожидает.
+
+Установка
+---------
+
+```
+composer require dmitry-suffi/RedisSessionHandler
+```
+
+Использование
+-------------
+
+```php
+
+
+$redis = new Redis();
+if ($redis->pconnect('11.111.111.11', 6379') && $redis->select(0)) {
+    $handler = new \suffi\RedisSessionHandler\RedisSessionHandler($redis);
+    session_set_save_handler($handler);
+}
+
+session_start();
+
+```
+

composer.json

@@ -0,0 +1,13 @@
+{
+    "name": "dmitry-suffi/RedisSessionHandler",
+    "description": "Обработчик сессий через Redis с механизмом блокировки",
+    "license": "MIT",
+    "keywords": ["redis", "session"],
+    "homepage": "https://github.com/dmitry-suffi/RedisSessionHandler",
+    "type": "project",
+    "autoload": {
+        "psr-4": {
+            "suffi\\RedisSessionHandler\\": "src\\"
+        }
+    }
+}

src/RedisSessionHandler.php

@@ -0,0 +1,236 @@
+<?php
+
+namespace suffi\RedisSessionHandler;
+
+/**
+ * Class RedisSessionHandler
+ * @package suffi\RedisSessionHandler
+ */
+class RedisSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * Инстанс редиса
+     * @var \Redis
+     */
+    protected $redis;
+
+    /**
+     * Время жизни сессии
+     * @var int
+     */
+    protected $ttl;
+
+    /**
+     * Префикс
+     * @var string
+     */
+    protected $prefix;
+
+    /**
+     * Флаг блокировки
+     * @var bool
+     */
+    protected $locked;
+
+    /**
+     * Ключ блокировки
+     * @var string
+     */
+    private $lockKey;
+
+    /**
+     * Токен блокировки
+     * @var string
+     */
+    private $token;
+
+    /**
+     * Время между попытками разблокировки
+     * @var int
+     */
+    private $spinLockWait;
+
+    /**
+     * Максимальное время ожидания разблокировки
+     * @var int
+     */
+    private $lockMaxWait;
+
+    /**
+     * RedisSessionHandler constructor.
+     * @param \Redis $redis
+     * @param string $prefix
+     * @param int $spinLockWait
+     */
+    public function __construct(\Redis $redis, $prefix = 'session_key', $spinLockWait = 200000)
+    {
+        $this->redis = $redis;
+
+        $this->ttl = ini_get('gc_maxlifetime');
+        $iniMaxExecutionTime = ini_get('max_execution_time');
+        $this->lockMaxWait = $iniMaxExecutionTime ? $iniMaxExecutionTime * 0.7 : 20;
+
+        $this->prefix = $prefix;
+        $this->locked = false;
+        $this->lockKey = null;
+        $this->spinLockWait = $spinLockWait;
+
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function open($savePath, $sessionName)
+    {
+        return true;
+    }
+
+    /**
+     * Попытка разблокировать сессию
+     */
+    protected function lockSession($sessionId)
+    {
+        $attempts = (1000000 * $this->lockMaxWait) / $this->spinLockWait;
+
+        $this->token = uniqid();
+        $this->lockKey = $sessionId . '.lock';
+        for ($i = 0; $i < $attempts; ++$i) {
+            $success = $this->redis->set(
+                $this->getRedisKey($this->lockKey),
+                $this->token,
+                [
+                    'NX', //Установить ключ только, если он уже не существует.
+                ]
+            );
+            if ($success) {
+                $this->locked = true;
+                return true;
+            }
+            usleep($this->spinLockWait);
+        }
+        return false;
+    }
+
+    /**
+     * Снятие блокировки сессии
+     */
+    private function unlockSession()
+    {
+        $script = <<<LUA
+if redis.call("GET", KEYS[1]) == ARGV[1] then
+    return redis.call("DEL", KEYS[1])
+else
+    return 0
+end
+LUA;
+
+        $this->redis->eval($script, array($this->getRedisKey($this->lockKey), $this->token), 1);
+
+        $this->locked = false;
+        $this->token = null;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function close()
+    {
+
+        if ($this->locked) {
+            $this->unlockSession();
+        }
+
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function read($sessionId)
+    {
+
+        if (!$this->locked) {
+            if (!$this->lockSession($sessionId)) {
+                return false;
+            }
+        }
+
+        return $this->redis->get($this->getRedisKey($sessionId)) ?: '';
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function write($sessionId, $data)
+    {
+        if ($this->ttl > 0) {
+            $this->redis->setex($this->getRedisKey($sessionId), $this->ttl, $data);
+        } else {
+            $this->redis->set($this->getRedisKey($sessionId), $data);
+        }
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function destroy($sessionId)
+    {
+        $this->redis->del($this->getRedisKey($sessionId));
+        $this->close();
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function gc($lifetime)
+    {
+        return true;
+    }
+
+    /**
+     * Установка времени жизни сессии
+     * @param int $ttl
+     */
+    public function setTtl($ttl)
+    {
+        $this->ttl = $ttl;
+    }
+
+    /**
+     * Максимальное время ожидания разблокировки
+     * @return int
+     */
+    public function getLockMaxWait()
+    {
+        return $this->lockMaxWait;
+    }
+
+    /**
+     * Максимальное время ожидания разблокировки
+     * @param int $lockMaxWait
+     */
+    public function setLockMaxWait($lockMaxWait)
+    {
+        $this->lockMaxWait = $lockMaxWait;
+    }
+
+    /**
+     * Подготовка ключа
+     * @param string $key key
+     * @return string prefixed key
+     */
+    protected function getRedisKey($key)
+    {
+        if (empty($this->prefix)) {
+            return $key;
+        }
+        return $this->prefix . $key;
+    }
+    
+    public function __destruct()
+    {
+        $this->close();
+    }
+}

tests/Readme.md

@@ -0,0 +1,7 @@
+Запуск тестов
+=============
+
+```
+phpunit --colors=always --bootstrap=tests/autoload.php tests/
+```
+

tests/RedisSessionHandlerTest.php

@@ -0,0 +1,44 @@
+<?php
+
+use \suffi\RedisSessionHandler\RedisSessionHandler;
+
+class RedisSessionHandlerTest extends \PHPUnit\Framework\TestCase
+{
+
+    public function getRedis()
+    {
+        $savePath = ini_get('session.save_path');
+        $redis = new Redis();
+        $redis->pconnect($savePath);
+        $redis->select(963);
+        return $redis;
+    }
+
+    public function testReadWrite()
+    {
+        $handler = new RedisSessionHandler($this->getRedis());
+
+        $sessionId = 'ses' . uniqid();
+        $handler->write($sessionId, 'session data');
+
+        $this->assertEquals($handler->read($sessionId), 'session data');
+    }
+
+    public function testLock()
+    {
+        $handler1 = new RedisSessionHandler($this->getRedis());
+        $handler2 = new RedisSessionHandler($this->getRedis());
+
+        $sessionId = 'ses' . uniqid();
+        $handler1->write($sessionId, 'session data');
+        $this->assertEquals($handler1->read($sessionId), 'session data');
+
+        $handler2->setLockMaxWait(5);
+        $this->assertNotEquals($handler2->read($sessionId), 'session data');
+        $this->assertFalse($handler2->read($sessionId));
+
+        $handler1->close();
+        $this->assertEquals($handler2->read($sessionId), 'session data');
+    }
+
+}

tests/autoload.php

@@ -0,0 +1,30 @@
+<?php
+
+spl_autoload_register(function ($class) {
+
+    // project-specific namespace prefix
+    $prefix = 'suffi\RedisSessionHandler';
+
+    // base directory for the namespace prefix
+    $base_dir = __DIR__ . '/../src';
+
+    // does the class use the namespace prefix?
+    $len = strlen($prefix);
+    if (strncmp($prefix, $class, $len) !== 0) {
+        // no, move to the next registered autoloader
+        return;
+    }
+
+    // get the relative class name
+    $relative_class = substr($class, $len);
+
+    // replace the namespace prefix with the base directory, replace namespace
+    // separators with directory separators in the relative class name, append
+    // with .php
+    $file = $base_dir . str_replace('\\', '/', $relative_class) . '.php';
+
+    // if the file exists, require it
+    if (file_exists($file)) {
+        require $file;
+    }
+});