Upgrade improve for laravel/lumen all version

Author: ginnerpeace

README.md

@@ -11,16 +11,14 @@
 
 ### Install
 > Using composer.
-```bash
-# Laravel/Lumen < 5.4
-composer require "ginnerpeace/laravel-redis-lock:~1.1"
 
-# Laravel/Lumen >= 5.4
-composer require "ginnerpeace/laravel-redis-lock:~2.1"
+```bash"
+composer require "ginnerpeace/laravel-redis-lock:~2.2"
 ```
 
 ### Add service provider:
 > Normally.
+
 ```php
 <?php
 return [
@@ -39,6 +37,7 @@ return [
 ```
 
 > After Laravel 5.5, the package auto-discovery is supported.
+
 ```javascript
 {
     "providers": [
@@ -51,12 +50,14 @@ return [
 ```
 
 > Lumen
+
 ```php
 $app->register(RedisLock\Providers\LumenRedisLockServiceProvider::class);
 ```
 
 ### Publish resources (laravel only)
 > Copied config to `config/redislock.php`.
+
 ```bash
 php artisan vendor:publish --provider="RedisLock\Providers\RedisLockServiceProvider"
 ```
@@ -107,11 +108,29 @@ $payload = RedisLock::lock('key', 100000);
 // Return bool.
 RedisLock::unlock($payload);
 
+// Determine a lock if it still effective.
+RedisLock::verify($payload);
+
+// Delay a lock if it still effective.
+RedisLock::delay($payload);
+
+/////////////////////
+// Special usages: //
+/////////////////////
+
 // Try 5 times if can't get lock at first hit.
-// Default value: 3
-RedisLock::setRetry(5)->lock('key', 100000);
+// Default value is property: retryCount it from config('redislock.retry_count')
+RedisLock::lock('key', 100000, 5);
 
 // Try once only.
-RedisLock::lock('key', 100000, false);
+RedisLock::lock('key', 100000, 1);
+// If value less than 1, will try at least once.
+// But not pretty...
+// RedisLock::lock('key', 100000, 0);
+// RedisLock::lock('key', 100000, -1);
+
+// Change default retry delay.
+// Try 10 times & every retry be apart 500 ~ 1000 milliseconds.
+RedisLock::setRetryDelay(1000)->lock('key', 100000, 10);
 
 ```

composer.json

@@ -2,7 +2,7 @@
     "name": "ginnerpeace/laravel-redis-lock",
     "homepage": "https://github.com/ginnerpeace/laravel-redis-lock",
     "description": "Simple mutex lock, redis edition.",
-    "keywords": ["redis", "mutex lock", "laravel"],
+    "keywords": ["redis", "mutex lock", "laravel", "lumen"],
     "license": "MIT",
     "authors": [
         {
@@ -13,9 +13,9 @@
     ],
     "require": {
         "php": "^7.0",
-        "illuminate/redis": "^5.4",
-        "illuminate/support": "^5.4",
-        "predis/predis": "~1.0"
+        "illuminate/redis": "^5.1",
+        "illuminate/support": "^5.1",
+        "predis/predis": "~1.1"
     },
     "autoload": {
         "psr-4": {

src/Processor.php

@@ -2,7 +2,7 @@
 
 namespace RedisLock;
 
-use Predis\Client;
+use Predis\ClientInterface;
 use RedisLock\LuaScripts;
 
 /**
@@ -25,7 +25,7 @@ class Processor
     // Response string from redis cmd: set
     const LOCK_SUCCESS = 'OK';
 
-    // Response string from redis lua script: eval
+    // Response int from redis lua script: redis.call('del', KEY)
     const UNLOCK_SUCCESS = 1;
 
     // Params for cmd: set
@@ -52,39 +52,34 @@ class Processor
     private $expireType;
 
     /**
-     * How many times do you want to try again.
-     *     (milliseconds)
+     * Number of retry times.
      *
-     * @var  integer
+     * @var  int
      */
-    private $retryDelay = 200;
+    private $retryCount = 3;
 
     /**
-     * Number of retry times.
+     * How many times do you want to try again.
+     *     (milliseconds)
      *
      * @var  int
      */
-    private $retryCount = 3;
+    private $retryDelay = 200;
 
     /**
      * This params from service provider.
      *
-     * @param   Predis\Client  $client
-     * @param   array|null  $config
+     * @param   Predis\ClientInterface  $client
+     * @param   int  $retryCount
+     * @param   int  $retryDelay
      */
-    public function __construct(Client $client, array $config = null)
+    public function __construct(ClientInterface $client, int $retryCount, int $retryDelay)
     {
         $this->client = $client;
 
-        if (isset($config['retry'])) {
-            $this->retryCount = $config['retry'];
-        }
-
-        if (isset($config['delay'])) {
-            $this->retryDelay = $config['delay'];
-        }
-
         $this->setExpireType(self::EXPIRE_TIME_MILLISECONDS);
+        $this->setRetryDelay($retryDelay);
+        $this->retryCount = $retryCount;
     }
 
     /**
@@ -101,14 +96,13 @@ public function setExpireType(string $value): self
     }
 
     /**
-     * Set retry number of times.
+     * Set retry delay time.
      *
-     * @param   int  $retry
-     * @return  self
+     * @param  int  $milliseconds
      */
-    public function setRetry(int $retry): self
+    public function setRetryDelay(int $milliseconds): self
     {
-        $this->retryCount = $retry;
+        $this->retryDelay = $milliseconds;
 
         return $this;
     }
@@ -118,17 +112,17 @@ public function setRetry(int $retry): self
      *
      * @param   string  $key
      * @param   int  $expire
-     * @param   bool  $isWaitingMode
+     * @param   int  $retry
      * @return  array
      *          - Not empty for getted lock.
      *          - Empty for lock timeout.
      */
-    public function lock(string $key, int $expire, bool $isWaitingMode = true): array
+    public function lock(string $key, int $expire, int $retry = null): array
     {
-        $retry = $isWaitingMode ? $this->retryCount : 0;
+        $retry = $retry ?? $this->retryCount ?? 0;
 
         while (! $result = $this->hit($key, $expire)) {
-            if (--$retry < 0) {
+            if (--$retry < 1) {
                 return $result;
             }
 

src/Providers/LumenRedisLockServiceProvider.php

@@ -12,4 +12,20 @@ public function boot()
         $this->app->configure('redislock');
         $this->mergeConfigFrom(__DIR__ . '/../redislock.config.php', 'redislock');
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function versionCompare(string $compareVersion, string $operator)
+    {
+        // Lumen (5.8.12) (Laravel Components 5.8.*)
+        $lumenVersion = $this->app->version();
+
+        if (preg_match('/Lumen \((\d\.\d\.\d{1,2})\)( \(Laravel Components (\d\.\d\.\*)\))?/', $lumenVersion, $matches)) {
+            // Prefer Laravel Components version.
+            $lumenVersion = isset($matches[3]) ? $matches[3] : $matches[1];
+        }
+
+        return version_compare($lumenVersion, $compareVersion, $operator);
+    }
 }

src/Providers/RedisLockServiceProvider.php

@@ -24,9 +24,17 @@ public function register()
     {
         $this->app->singleton(Processor::class, function($app) {
             $config = $app['config']['redislock'];
+
+            if ($this->versionCompare('5.4', '>=')) {
+                $predisClient = $app['redis']->connection($config['connection'])->client();
+            } else {
+                $predisClient = $app['redis']->connection($config['connection']);
+            }
+
             return new Processor(
-                $app['redis']->connection($config['connection'])->client(),
-                $config
+                $predisClient,
+                $config['retry_count'],
+                $config['retry_delay']
             );
         });
     }
@@ -46,4 +54,17 @@ public function provides()
     {
         return [Processor::class];
     }
+
+    /**
+     * Compare illuminate component version.
+     *     - illuminate/redis 5.4 has a big upgrade.
+     *
+     * @param   string  $compareVersion
+     * @param   string  $operator
+     * @return  bool|null
+     */
+    protected function versionCompare(string $compareVersion, string $operator)
+    {
+        return version_compare($this->app->version(), $compareVersion, $operator);
+    }
 }

src/redislock.config.php

@@ -2,6 +2,6 @@
 
 return [
     'connection' => 'default',
-    'retry' => 3,
-    'delay' => 200,
+    'retry_count' => 3,
+    'retry_delay' => 200,
 ];