Cache locks.

This commit adds atomic lock support to the Memcached and Redis drivers
of the cache system, allowing for simple manipulation of “locks”
without worrying about race conditions.

Author: taylorotwell

src/Illuminate/Cache/Lock.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Cache\LockTimeoutException;
+
+abstract class Lock
+{
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    abstract public function acquire();
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @param  callable|null  $callback
+     * @return bool
+     */
+    public function get($callback = null)
+    {
+        $result = $this->acquire();
+
+        if ($result && is_callable($callback)) {
+            return tap($callback(), function () {
+                $this->release();
+            });
+        }
+
+        return $result;
+    }
+
+    /**
+     * Attempt to acquire the lock while blocking indefinitely.
+     *
+     * @param  callable|null  $calback
+     * @return bool
+     */
+    public function block($callback = null)
+    {
+        while (! $this->acquire()) {
+            usleep(250 * 1000);
+        }
+
+        if (is_callable($callback)) {
+            return tap($callback(), function () {
+                $this->release();
+            });
+        }
+
+        return true;
+    }
+
+    /**
+     * Attempt to acquire the lock for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @param  callable|null  $callback
+     * @return bool
+     */
+    public function blockFor($seconds, $callback = null)
+    {
+        $starting = Carbon::now();
+
+        while (! $this->acquire()) {
+            usleep(250 * 1000);
+
+            if (Carbon::now()->subSeconds($seconds)->gte($starting)) {
+                throw new LockTimeoutException;
+            }
+        }
+
+        if (is_callable($callback)) {
+            return tap($callback(), function () {
+                $this->release();
+            });
+        }
+
+        return true;
+    }
+}

src/Illuminate/Cache/MemcachedLock.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Cache\Lock as LockContract;
+
+class MemcachedLock extends Lock implements LockContract
+{
+    /**
+     * The Memcached instance.
+     *
+     * @var \Memcached
+     */
+    protected $memcached;
+
+    /**
+     * The name of the lock.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The number of seconds the lock should be maintained.
+     *
+     * @var int
+     */
+    protected $seconds;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Memcached  $memcached
+     * @param  string  $name
+     * @param  int  $seconds
+     * @return void
+     */
+    public function __construct($memcached, $name, $seconds)
+    {
+        $this->name = $name;
+        $this->seconds = $seconds;
+        $this->memcached = $memcached;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        return $this->memcached->add(
+            $this->name, 1, $this->seconds
+        );
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return void
+     */
+    public function release()
+    {
+        $this->memcached->delete($this->name);
+    }
+}

src/Illuminate/Cache/MemcachedStore.php

@@ -6,8 +6,9 @@
 use Carbon\Carbon;
 use ReflectionMethod;
 use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Cache\LockProvider;
 
-class MemcachedStore extends TaggableStore implements Store
+class MemcachedStore extends TaggableStore implements LockProvider, Store
 {
     /**
      * The Memcached instance.
@@ -170,6 +171,18 @@ public function forever($key, $value)
         $this->put($key, $value, 0);
     }
 
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0)
+    {
+        return new MemcachedLock($this->memcached, $this->prefix.$name, $seconds);
+    }
+
     /**
      * Remove an item from the cache.
      *

src/Illuminate/Cache/RedisLock.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Carbon\Carbon;
+use Illuminate\Contracts\Cache\Lock as LockContract;
+
+class RedisLock extends Lock implements LockContract
+{
+    /**
+     * The Redis factory implementation.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    protected $redis;
+
+    /**
+     * The name of the lock.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The number of seconds the lock should be maintained.
+     *
+     * @var int
+     */
+    protected $seconds;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $redis
+     * @param  string  $name
+     * @param  int  $seconds
+     * @return void
+     */
+    public function __construct($redis, $name, $seconds)
+    {
+        $this->name = $name;
+        $this->redis = $redis;
+        $this->seconds = $seconds;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        $result = $this->redis->setnx($this->name, 1);
+
+        if ($result === 1) {
+            $this->redis->expire($this->name, $this->seconds);
+        }
+
+        return $result === 1;
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return void
+     */
+    public function release()
+    {
+        $this->redis->del($this->name);
+    }
+}

src/Illuminate/Cache/RedisStore.php

@@ -165,6 +165,18 @@ public function forever($key, $value)
         $this->connection()->set($this->prefix.$key, $this->serialize($value));
     }
 
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0)
+    {
+        return new RedisLock($this->connection(), $this->prefix.$name, $seconds);
+    }
+
     /**
      * Remove an item from the cache.
      *

src/Illuminate/Contracts/Cache/Lock.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Contracts\Cache;
+
+interface Lock
+{
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @param  callable|null  $callback
+     * @return bool
+     */
+    public function get($callback = null);
+
+    /**
+     * Attempt to acquire the lock while blocking indefinitely.
+     *
+     * @param  callable|null  $calback
+     * @return bool
+     */
+    public function block($callback = null);
+
+    /**
+     * Attempt to acquire the lock for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @param  callable|null  $callback
+     * @return bool
+     */
+    public function blockFor($seconds, $callback = null);
+
+    /**
+     * Release the lock.
+     *
+     * @return void
+     */
+    public function release();
+}

src/Illuminate/Contracts/Cache/LockProvider.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Illuminate\Contracts\Cache;
+
+interface LockProvider
+{
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0);
+}

src/Illuminate/Contracts/Cache/LockTimeoutException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Illuminate\Contracts\Cache;
+
+use Exception;
+
+class LockTimeoutException extends Exception
+{
+    //
+}