Upgrade framework

vendor/laravel/framework/src/Illuminate/Cache/ApcStore.php

@@ -2,9 +2,7 @@
 
 namespace Illuminate\Cache;
 
-use Illuminate\Contracts\Cache\Store;
-
-class ApcStore extends TaggableStore implements Store
+class ApcStore extends TaggableStore
 {
     use RetrievesMultipleKeys;
 
@@ -51,23 +49,23 @@ class ApcStore extends TaggableStore implements Store
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
-        $this->apc->put($this->prefix.$key, $value, (int) ($minutes * 60));
+        return $this->apc->put($this->prefix.$key, $value, $seconds);
     }
 
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function increment($key, $value = 1)
@@ -79,7 +77,7 @@ class ApcStore extends TaggableStore implements Store
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function decrement($key, $value = 1)
@@ -91,12 +89,12 @@ class ApcStore extends TaggableStore implements Store
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->put($key, $value, 0);
+        return $this->put($key, $value, 0);
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/ApcWrapper.php

@@ -36,8 +36,8 @@ class ApcWrapper
      * Store an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  int     $seconds
+     * @param  mixed  $value
+     * @param  int  $seconds
      * @return array|bool
      */
     public function put($key, $value, $seconds)
@@ -49,7 +49,7 @@ class ApcWrapper
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function increment($key, $value)
@@ -61,7 +61,7 @@ class ApcWrapper
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function decrement($key, $value)

vendor/laravel/framework/src/Illuminate/Cache/ArrayLock.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Illuminate\Support\Carbon;
+
+class ArrayLock extends Lock
+{
+    /**
+     * The parent array cache store.
+     *
+     * @var \Illuminate\Cache\ArrayStore
+     */
+    protected $store;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Cache\ArrayStore  $store
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct($store, $name, $seconds, $owner = null)
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->store = $store;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        $expiration = $this->store->locks[$this->name]['expiresAt'] ?? Carbon::now()->addSecond();
+
+        if ($this->exists() && $expiration->isFuture()) {
+            return false;
+        }
+
+        $this->store->locks[$this->name] = [
+            'owner' => $this->owner,
+            'expiresAt' => $this->seconds === 0 ? null : Carbon::now()->addSeconds($this->seconds),
+        ];
+
+        return true;
+    }
+
+    /**
+     * Determine if the current lock exists.
+     *
+     * @return bool
+     */
+    protected function exists()
+    {
+        return isset($this->store->locks[$this->name]);
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        if (! $this->exists()) {
+            return false;
+        }
+
+        if (! $this->isOwnedByCurrentProcess()) {
+            return false;
+        }
+
+        $this->forceRelease();
+
+        return true;
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return string
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->store->locks[$this->name]['owner'];
+    }
+
+    /**
+     * Releases this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        unset($this->store->locks[$this->name]);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/ArrayStore.php

@@ -2,11 +2,12 @@
 
 namespace Illuminate\Cache;
 
-use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Cache\LockProvider;
+use Illuminate\Support\InteractsWithTime;
 
-class ArrayStore extends TaggableStore implements Store
+class ArrayStore extends TaggableStore implements LockProvider
 {
-    use RetrievesMultipleKeys;
+    use InteractsWithTime, RetrievesMultipleKeys;
 
     /**
      * The array of stored values.
@@ -15,6 +16,31 @@ class ArrayStore extends TaggableStore implements Store
      */
     protected $storage = [];
 
+    /**
+     * The array of locks.
+     *
+     * @var array
+     */
+    public $locks = [];
+
+    /**
+     * Indicates if values are serialized within the store.
+     *
+     * @var bool
+     */
+    protected $serializesValues;
+
+    /**
+     * Create a new Array store.
+     *
+     * @param  bool  $serializesValues
+     * @return void
+     */
+    public function __construct($serializesValues = false)
+    {
+        $this->serializesValues = $serializesValues;
+    }
+
     /**
      * Retrieve an item from the cache by key.
      *
@@ -23,44 +49,68 @@ class ArrayStore extends TaggableStore implements Store
      */
     public function get($key)
     {
-        if (array_key_exists($key, $this->storage)) {
-            return $this->storage[$key];
+        if (! isset($this->storage[$key])) {
+            return;
         }
+
+        $item = $this->storage[$key];
+
+        $expiresAt = $item['expiresAt'] ?? 0;
+
+        if ($expiresAt !== 0 && $this->currentTime() > $expiresAt) {
+            $this->forget($key);
+
+            return;
+        }
+
+        return $this->serializesValues ? unserialize($item['value']) : $item['value'];
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
-        $this->storage[$key] = $value;
+        $this->storage[$key] = [
+            'value' => $this->serializesValues ? serialize($value) : $value,
+            'expiresAt' => $this->calculateExpiration($seconds),
+        ];
+
+        return true;
     }
 
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function increment($key, $value = 1)
     {
-        $this->storage[$key] = ! isset($this->storage[$key])
-                ? $value : ((int) $this->storage[$key]) + $value;
+        if (! is_null($existing = $this->get($key))) {
+            return tap(((int) $existing) + $value, function ($incremented) use ($key) {
+                $value = $this->serializesValues ? serialize($incremented) : $incremented;
 
-        return $this->storage[$key];
+                $this->storage[$key]['value'] = $value;
+            });
+        }
+
+        $this->forever($key, $value);
+
+        return $value;
     }
 
     /**
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function decrement($key, $value = 1)
@@ -72,12 +122,12 @@ class ArrayStore extends TaggableStore implements Store
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->put($key, $value, 0);
+        return $this->put($key, $value, 0);
     }
 
     /**
@@ -88,9 +138,13 @@ class ArrayStore extends TaggableStore implements Store
      */
     public function forget($key)
     {
-        unset($this->storage[$key]);
+        if (array_key_exists($key, $this->storage)) {
+            unset($this->storage[$key]);
 
-        return true;
+            return true;
+        }
+
+        return false;
     }
 
     /**
@@ -114,4 +168,51 @@ class ArrayStore extends TaggableStore implements Store
     {
         return '';
     }
+
+    /**
+     * Get the expiration time of the key.
+     *
+     * @param  int  $seconds
+     * @return int
+     */
+    protected function calculateExpiration($seconds)
+    {
+        return $this->toTimestamp($seconds);
+    }
+
+    /**
+     * Get the UNIX timestamp for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @return int
+     */
+    protected function toTimestamp($seconds)
+    {
+        return $seconds > 0 ? $this->availableAt($seconds) : 0;
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new ArrayLock($this, $name, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
+    }
 }

vendor/laravel/framework/src/Illuminate/Cache/CacheLock.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class CacheLock extends Lock
+{
+    /**
+     * The cache store implementation.
+     *
+     * @var \Illuminate\Contracts\Cache\Store
+     */
+    protected $store;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Contracts\Cache\Store  $store
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct($store, $name, $seconds, $owner = null)
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->store = $store;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        if (method_exists($this->store, 'add') && $this->seconds > 0) {
+            return $this->store->add(
+                $this->name, $this->owner, $this->seconds
+            );
+        }
+
+        if (! is_null($this->store->get($this->name))) {
+            return false;
+        }
+
+        return ($this->seconds > 0)
+                ? $this->store->put($this->name, $this->owner, $this->seconds)
+                : $this->store->forever($this->name, $this->owner);
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        if ($this->isOwnedByCurrentProcess()) {
+            return $this->store->forget($this->name);
+        }
+
+        return false;
+    }
+
+    /**
+     * Releases this lock regardless of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        $this->store->forget($this->name);
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return mixed
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->store->get($this->name);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/CacheManager.php

@@ -2,19 +2,24 @@
 
 namespace Illuminate\Cache;
 
+use Aws\DynamoDb\DynamoDbClient;
 use Closure;
+use Illuminate\Contracts\Cache\Factory as FactoryContract;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Events\Dispatcher as DispatcherContract;
 use Illuminate\Support\Arr;
 use InvalidArgumentException;
-use Illuminate\Contracts\Cache\Store;
-use Illuminate\Contracts\Cache\Factory as FactoryContract;
-use Illuminate\Contracts\Events\Dispatcher as DispatcherContract;
 
+/**
+ * @mixin \Illuminate\Cache\Repository
+ * @mixin \Illuminate\Contracts\Cache\LockProvider
+ */
 class CacheManager implements FactoryContract
 {
     /**
      * The application instance.
      *
-     * @var \Illuminate\Foundation\Application
+     * @var \Illuminate\Contracts\Foundation\Application
      */
     protected $app;
 
@@ -35,7 +40,7 @@ class CacheManager implements FactoryContract
     /**
      * Create a new Cache manager instance.
      *
-     * @param  \Illuminate\Foundation\Application  $app
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
      * @return void
      */
     public function __construct($app)
@@ -44,10 +49,10 @@ class CacheManager implements FactoryContract
     }
 
     /**
-     * Get a cache store instance by name.
+     * Get a cache store instance by name, wrapped in a repository.
      *
      * @param  string|null  $name
-     * @return mixed
+     * @return \Illuminate\Contracts\Cache\Repository
      */
     public function store($name = null)
     {
@@ -59,8 +64,8 @@ class CacheManager implements FactoryContract
     /**
      * Get a cache driver instance.
      *
-     * @param  string  $driver
-     * @return mixed
+     * @param  string|null  $driver
+     * @return \Illuminate\Contracts\Cache\Repository
      */
     public function driver($driver = null)
     {
@@ -75,7 +80,7 @@ class CacheManager implements FactoryContract
      */
     protected function get($name)
     {
-        return isset($this->stores[$name]) ? $this->stores[$name] : $this->resolve($name);
+        return $this->stores[$name] ?? $this->resolve($name);
     }
 
     /**
@@ -122,7 +127,7 @@ class CacheManager implements FactoryContract
      * Create an instance of the APC cache driver.
      *
      * @param  array  $config
-     * @return \Illuminate\Cache\ApcStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createApcDriver(array $config)
     {
@@ -134,29 +139,30 @@ class CacheManager implements FactoryContract
     /**
      * Create an instance of the array cache driver.
      *
-     * @return \Illuminate\Cache\ArrayStore
+     * @param  array  $config
+     * @return \Illuminate\Cache\Repository
      */
-    protected function createArrayDriver()
+    protected function createArrayDriver(array $config)
     {
-        return $this->repository(new ArrayStore);
+        return $this->repository(new ArrayStore($config['serialize'] ?? false));
     }
 
     /**
      * Create an instance of the file cache driver.
      *
      * @param  array  $config
-     * @return \Illuminate\Cache\FileStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createFileDriver(array $config)
     {
-        return $this->repository(new FileStore($this->app['files'], $config['path']));
+        return $this->repository(new FileStore($this->app['files'], $config['path'], $config['permission'] ?? null));
     }
 
     /**
      * Create an instance of the Memcached cache driver.
      *
      * @param  array  $config
-     * @return \Illuminate\Cache\MemcachedStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createMemcachedDriver(array $config)
     {
@@ -164,9 +170,9 @@ class CacheManager implements FactoryContract
 
         $memcached = $this->app['memcached.connector']->connect(
             $config['servers'],
-            array_get($config, 'persistent_id'),
-            array_get($config, 'options', []),
-            array_filter(array_get($config, 'sasl', []))
+            $config['persistent_id'] ?? null,
+            $config['options'] ?? [],
+            array_filter($config['sasl'] ?? [])
         );
 
         return $this->repository(new MemcachedStore($memcached, $prefix));
@@ -175,7 +181,7 @@ class CacheManager implements FactoryContract
     /**
      * Create an instance of the Null cache driver.
      *
-     * @return \Illuminate\Cache\NullStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createNullDriver()
     {
@@ -186,34 +192,88 @@ class CacheManager implements FactoryContract
      * Create an instance of the Redis cache driver.
      *
      * @param  array  $config
-     * @return \Illuminate\Cache\RedisStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createRedisDriver(array $config)
     {
         $redis = $this->app['redis'];
 
-        $connection = Arr::get($config, 'connection', 'default');
+        $connection = $config['connection'] ?? 'default';
 
-        return $this->repository(new RedisStore($redis, $this->getPrefix($config), $connection));
+        $store = new RedisStore($redis, $this->getPrefix($config), $connection);
+
+        return $this->repository(
+            $store->setLockConnection($config['lock_connection'] ?? $connection)
+        );
     }
 
     /**
      * Create an instance of the database cache driver.
      *
      * @param  array  $config
-     * @return \Illuminate\Cache\DatabaseStore
+     * @return \Illuminate\Cache\Repository
      */
     protected function createDatabaseDriver(array $config)
     {
-        $connection = $this->app['db']->connection(Arr::get($config, 'connection'));
+        $connection = $this->app['db']->connection($config['connection'] ?? null);
+
+        $store = new DatabaseStore(
+            $connection,
+            $config['table'],
+            $this->getPrefix($config),
+            $config['lock_table'] ?? 'cache_locks',
+            $config['lock_lottery'] ?? [2, 100]
+        );
+
+        return $this->repository($store->setLockConnection(
+            $this->app['db']->connection($config['lock_connection'] ?? $config['connection'] ?? null)
+        ));
+    }
+
+    /**
+     * Create an instance of the DynamoDB cache driver.
+     *
+     * @param  array  $config
+     * @return \Illuminate\Cache\Repository
+     */
+    protected function createDynamodbDriver(array $config)
+    {
+        $client = $this->newDynamodbClient($config);
 
         return $this->repository(
-            new DatabaseStore(
-                $connection, $this->app['encrypter'], $config['table'], $this->getPrefix($config)
+            new DynamoDbStore(
+                $client,
+                $config['table'],
+                $config['attributes']['key'] ?? 'key',
+                $config['attributes']['value'] ?? 'value',
+                $config['attributes']['expiration'] ?? 'expires_at',
+                $this->getPrefix($config)
             )
         );
     }
 
+    /**
+     * Create new DynamoDb Client instance.
+     *
+     * @return \Aws\DynamoDb\DynamoDbClient
+     */
+    protected function newDynamodbClient(array $config)
+    {
+        $dynamoConfig = [
+            'region' => $config['region'],
+            'version' => 'latest',
+            'endpoint' => $config['endpoint'] ?? null,
+        ];
+
+        if (isset($config['key'], $config['secret'])) {
+            $dynamoConfig['credentials'] = Arr::only(
+                $config, ['key', 'secret', 'token']
+            );
+        }
+
+        return new DynamoDbClient($dynamoConfig);
+    }
+
     /**
      * Create a new cache repository with the given implementation.
      *
@@ -222,15 +282,36 @@ class CacheManager implements FactoryContract
      */
     public function repository(Store $store)
     {
-        $repository = new Repository($store);
+        return tap(new Repository($store), function ($repository) {
+            $this->setEventDispatcher($repository);
+        });
+    }
 
-        if ($this->app->bound(DispatcherContract::class)) {
-            $repository->setEventDispatcher(
-                $this->app[DispatcherContract::class]
-            );
+    /**
+     * Set the event dispatcher on the given repository instance.
+     *
+     * @param  \Illuminate\Cache\Repository  $repository
+     * @return void
+     */
+    protected function setEventDispatcher(Repository $repository)
+    {
+        if (! $this->app->bound(DispatcherContract::class)) {
+            return;
         }
 
-        return $repository;
+        $repository->setEventDispatcher(
+            $this->app[DispatcherContract::class]
+        );
+    }
+
+    /**
+     * Re-set the event dispatcher on all resolved cache repositories.
+     *
+     * @return void
+     */
+    public function refreshEventDispatcher()
+    {
+        array_map([$this, 'setEventDispatcher'], $this->stores);
     }
 
     /**
@@ -241,18 +322,22 @@ class CacheManager implements FactoryContract
      */
     protected function getPrefix(array $config)
     {
-        return Arr::get($config, 'prefix') ?: $this->app['config']['cache.prefix'];
+        return $config['prefix'] ?? $this->app['config']['cache.prefix'];
     }
 
     /**
      * Get the cache connection configuration.
      *
      * @param  string  $name
-     * @return array
+     * @return array|null
      */
     protected function getConfig($name)
     {
-        return $this->app['config']["cache.stores.{$name}"];
+        if (! is_null($name) && $name !== 'null') {
+            return $this->app['config']["cache.stores.{$name}"];
+        }
+
+        return ['driver' => 'null'];
     }
 
     /**
@@ -276,10 +361,42 @@ class CacheManager implements FactoryContract
         $this->app['config']['cache.default'] = $name;
     }
 
+    /**
+     * Unset the given driver instances.
+     *
+     * @param  array|string|null  $name
+     * @return $this
+     */
+    public function forgetDriver($name = null)
+    {
+        $name ??= $this->getDefaultDriver();
+
+        foreach ((array) $name as $cacheName) {
+            if (isset($this->stores[$cacheName])) {
+                unset($this->stores[$cacheName]);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Disconnect the given driver and remove from local cache.
+     *
+     * @param  string|null  $name
+     * @return void
+     */
+    public function purge($name = null)
+    {
+        $name ??= $this->getDefaultDriver();
+
+        unset($this->stores[$name]);
+    }
+
     /**
      * Register a custom driver creator Closure.
      *
-     * @param  string    $driver
+     * @param  string  $driver
      * @param  \Closure  $callback
      * @return $this
      */
@@ -294,7 +411,7 @@ class CacheManager implements FactoryContract
      * Dynamically call the default driver instance.
      *
      * @param  string  $method
-     * @param  array   $parameters
+     * @param  array  $parameters
      * @return mixed
      */
     public function __call($method, $parameters)

vendor/laravel/framework/src/Illuminate/Cache/CacheServiceProvider.php

@@ -2,17 +2,12 @@
 
 namespace Illuminate\Cache;
 
+use Illuminate\Contracts\Support\DeferrableProvider;
 use Illuminate\Support\ServiceProvider;
+use Symfony\Component\Cache\Adapter\Psr16Adapter;
 
-class CacheServiceProvider extends ServiceProvider
+class CacheServiceProvider extends ServiceProvider implements DeferrableProvider
 {
-    /**
-     * Indicates if loading of the provider is deferred.
-     *
-     * @var bool
-     */
-    protected $defer = true;
-
     /**
      * Register the service provider.
      *
@@ -28,9 +23,19 @@ class CacheServiceProvider extends ServiceProvider
             return $app['cache']->driver();
         });
 
+        $this->app->singleton('cache.psr6', function ($app) {
+            return new Psr16Adapter($app['cache.store']);
+        });
+
         $this->app->singleton('memcached.connector', function () {
             return new MemcachedConnector;
         });
+
+        $this->app->singleton(RateLimiter::class, function ($app) {
+            return new RateLimiter($app->make('cache')->driver(
+                $app['config']->get('cache.limiter')
+            ));
+        });
     }
 
     /**
@@ -41,7 +46,7 @@ class CacheServiceProvider extends ServiceProvider
     public function provides()
     {
         return [
-            'cache', 'cache.store', 'memcached.connector',
+            'cache', 'cache.store', 'cache.psr6', 'memcached.connector', RateLimiter::class,
         ];
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/Console/CacheTableCommand.php

@@ -3,9 +3,11 @@
 namespace Illuminate\Cache\Console;
 
 use Illuminate\Console\Command;
-use Illuminate\Support\Composer;
 use Illuminate\Filesystem\Filesystem;
+use Illuminate\Support\Composer;
+use Symfony\Component\Console\Attribute\AsCommand;
 
+#[AsCommand(name: 'cache:table')]
 class CacheTableCommand extends Command
 {
     /**
@@ -15,6 +17,17 @@ class CacheTableCommand extends Command
      */
     protected $name = 'cache:table';
 
+    /**
+     * The name of the console command.
+     *
+     * This name is used to identify the command during lazy loading.
+     *
+     * @var string|null
+     *
+     * @deprecated
+     */
+    protected static $defaultName = 'cache:table';
+
     /**
      * The console command description.
      *
@@ -54,13 +67,13 @@ class CacheTableCommand extends Command
      *
      * @return void
      */
-    public function fire()
+    public function handle()
     {
         $fullPath = $this->createBaseMigration();
 
         $this->files->put($fullPath, $this->files->get(__DIR__.'/stubs/cache.stub'));
 
-        $this->info('Migration created successfully!');
+        $this->components->info('Migration created successfully.');
 
         $this->composer->dumpAutoloads();
     }

vendor/laravel/framework/src/Illuminate/Cache/Console/ClearCommand.php

@@ -2,11 +2,14 @@
 
 namespace Illuminate\Cache\Console;
 
-use Illuminate\Console\Command;
 use Illuminate\Cache\CacheManager;
-use Symfony\Component\Console\Input\InputOption;
+use Illuminate\Console\Command;
+use Illuminate\Filesystem\Filesystem;
+use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputOption;
 
+#[AsCommand(name: 'cache:clear')]
 class ClearCommand extends Command
 {
     /**
@@ -16,6 +19,17 @@ class ClearCommand extends Command
      */
     protected $name = 'cache:clear';
 
+    /**
+     * The name of the console command.
+     *
+     * This name is used to identify the command during lazy loading.
+     *
+     * @var string|null
+     *
+     * @deprecated
+     */
+    protected static $defaultName = 'cache:clear';
+
     /**
      * The console command description.
      *
@@ -30,17 +44,26 @@ class ClearCommand extends Command
      */
     protected $cache;
 
+    /**
+     * The filesystem instance.
+     *
+     * @var \Illuminate\Filesystem\Filesystem
+     */
+    protected $files;
+
     /**
      * Create a new cache clear command instance.
      *
      * @param  \Illuminate\Cache\CacheManager  $cache
+     * @param  \Illuminate\Filesystem\Filesystem  $files
      * @return void
      */
-    public function __construct(CacheManager $cache)
+    public function __construct(CacheManager $cache, Filesystem $files)
     {
         parent::__construct();
 
         $this->cache = $cache;
+        $this->files = $files;
     }
 
     /**
@@ -50,13 +73,41 @@ class ClearCommand extends Command
      */
     public function handle()
     {
-        $this->laravel['events']->fire('cache:clearing', [$this->argument('store'), $this->tags()]);
+        $this->laravel['events']->dispatch(
+            'cache:clearing', [$this->argument('store'), $this->tags()]
+        );
 
-        $this->cache()->flush();
+        $successful = $this->cache()->flush();
 
-        $this->laravel['events']->fire('cache:cleared', [$this->argument('store'), $this->tags()]);
+        $this->flushFacades();
 
-        $this->info('Cache cleared successfully.');
+        if (! $successful) {
+            return $this->components->error('Failed to clear cache. Make sure you have the appropriate permissions.');
+        }
+
+        $this->laravel['events']->dispatch(
+            'cache:cleared', [$this->argument('store'), $this->tags()]
+        );
+
+        $this->components->info('Application cache cleared successfully.');
+    }
+
+    /**
+     * Flush the real-time facades stored in the cache directory.
+     *
+     * @return void
+     */
+    public function flushFacades()
+    {
+        if (! $this->files->exists($storagePath = storage_path('framework/cache'))) {
+            return;
+        }
+
+        foreach ($this->files->files($storagePath) as $file) {
+            if (preg_match('/facade-.*\.php$/', $file)) {
+                $this->files->delete($file);
+            }
+        }
     }
 
     /**
@@ -78,7 +129,7 @@ class ClearCommand extends Command
      */
     protected function tags()
     {
-        return array_filter(explode(',', $this->option('tags')));
+        return array_filter(explode(',', $this->option('tags') ?? ''));
     }
 
     /**
@@ -89,7 +140,7 @@ class ClearCommand extends Command
     protected function getArguments()
     {
         return [
-            ['store', InputArgument::OPTIONAL, 'The name of the store you would like to clear.'],
+            ['store', InputArgument::OPTIONAL, 'The name of the store you would like to clear'],
         ];
     }
 
@@ -101,7 +152,7 @@ class ClearCommand extends Command
     protected function getOptions()
     {
         return [
-            ['tags', null, InputOption::VALUE_OPTIONAL, 'The cache tags you would like to clear.', null],
+            ['tags', null, InputOption::VALUE_OPTIONAL, 'The cache tags you would like to clear', null],
         ];
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/Console/ForgetCommand.php

@@ -2,9 +2,11 @@
 
 namespace Illuminate\Cache\Console;
 
-use Illuminate\Console\Command;
 use Illuminate\Cache\CacheManager;
+use Illuminate\Console\Command;
+use Symfony\Component\Console\Attribute\AsCommand;
 
+#[AsCommand(name: 'cache:forget')]
 class ForgetCommand extends Command
 {
     /**
@@ -14,6 +16,17 @@ class ForgetCommand extends Command
      */
     protected $signature = 'cache:forget {key : The key to remove} {store? : The store to remove the key from}';
 
+    /**
+     * The name of the console command.
+     *
+     * This name is used to identify the command during lazy loading.
+     *
+     * @var string|null
+     *
+     * @deprecated
+     */
+    protected static $defaultName = 'cache:forget';
+
     /**
      * The console command description.
      *
@@ -52,6 +65,6 @@ class ForgetCommand extends Command
             $this->argument('key')
         );
 
-        $this->info('The ['.$this->argument('key').'] key has been removed from the cache.');
+        $this->components->info('The ['.$this->argument('key').'] key has been removed from the cache.');
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/Console/stubs/cache.stub

@@ -1,10 +1,10 @@
 <?php
 
-use Illuminate\Support\Facades\Schema;
-use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
 
-class CreateCacheTable extends Migration
+return new class extends Migration
 {
     /**
      * Run the migrations.
@@ -14,8 +14,14 @@ class CreateCacheTable extends Migration
     public function up()
     {
         Schema::create('cache', function (Blueprint $table) {
-            $table->string('key')->unique();
-            $table->text('value');
+            $table->string('key')->primary();
+            $table->mediumText('value');
+            $table->integer('expiration');
+        });
+
+        Schema::create('cache_locks', function (Blueprint $table) {
+            $table->string('key')->primary();
+            $table->string('owner');
             $table->integer('expiration');
         });
     }
@@ -28,5 +34,6 @@ class CreateCacheTable extends Migration
     public function down()
     {
         Schema::dropIfExists('cache');
+        Schema::dropIfExists('cache_locks');
     }
-}
+};

vendor/laravel/framework/src/Illuminate/Cache/DatabaseLock.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Illuminate\Database\Connection;
+use Illuminate\Database\QueryException;
+use Illuminate\Support\Carbon;
+
+class DatabaseLock extends Lock
+{
+    /**
+     * The database connection instance.
+     *
+     * @var \Illuminate\Database\Connection
+     */
+    protected $connection;
+
+    /**
+     * The database table name.
+     *
+     * @var string
+     */
+    protected $table;
+
+    /**
+     * The prune probability odds.
+     *
+     * @var array
+     */
+    protected $lottery;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Database\Connection  $connection
+     * @param  string  $table
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @param  array  $lottery
+     * @return void
+     */
+    public function __construct(Connection $connection, $table, $name, $seconds, $owner = null, $lottery = [2, 100])
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->connection = $connection;
+        $this->table = $table;
+        $this->lottery = $lottery;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        try {
+            $this->connection->table($this->table)->insert([
+                'key' => $this->name,
+                'owner' => $this->owner,
+                'expiration' => $this->expiresAt(),
+            ]);
+
+            $acquired = true;
+        } catch (QueryException $e) {
+            $updated = $this->connection->table($this->table)
+                ->where('key', $this->name)
+                ->where(function ($query) {
+                    return $query->where('owner', $this->owner)->orWhere('expiration', '<=', time());
+                })->update([
+                    'owner' => $this->owner,
+                    'expiration' => $this->expiresAt(),
+                ]);
+
+            $acquired = $updated >= 1;
+        }
+
+        if (random_int(1, $this->lottery[1]) <= $this->lottery[0]) {
+            $this->connection->table($this->table)->where('expiration', '<=', time())->delete();
+        }
+
+        return $acquired;
+    }
+
+    /**
+     * Get the UNIX timestamp indicating when the lock should expire.
+     *
+     * @return int
+     */
+    protected function expiresAt()
+    {
+        return $this->seconds > 0 ? time() + $this->seconds : Carbon::now()->addDays(1)->getTimestamp();
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        if ($this->isOwnedByCurrentProcess()) {
+            $this->connection->table($this->table)
+                        ->where('key', $this->name)
+                        ->where('owner', $this->owner)
+                        ->delete();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Releases this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        $this->connection->table($this->table)
+                    ->where('key', $this->name)
+                    ->delete();
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return string
+     */
+    protected function getCurrentOwner()
+    {
+        return optional($this->connection->table($this->table)->where('key', $this->name)->first())->owner;
+    }
+
+    /**
+     * Get the name of the database connection being used to manage the lock.
+     *
+     * @return string
+     */
+    public function getConnectionName()
+    {
+        return $this->connection->getName();
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/DatabaseStore.php

@@ -4,14 +4,17 @@ namespace Illuminate\Cache;
 
 use Closure;
 use Exception;
-use Carbon\Carbon;
+use Illuminate\Contracts\Cache\LockProvider;
 use Illuminate\Contracts\Cache\Store;
 use Illuminate\Database\ConnectionInterface;
-use Illuminate\Contracts\Encryption\Encrypter as EncrypterContract;
+use Illuminate\Database\PostgresConnection;
+use Illuminate\Database\QueryException;
+use Illuminate\Support\InteractsWithTime;
+use Illuminate\Support\Str;
 
-class DatabaseStore implements Store
+class DatabaseStore implements LockProvider, Store
 {
-    use RetrievesMultipleKeys;
+    use InteractsWithTime, RetrievesMultipleKeys;
 
     /**
      * The database connection instance.
@@ -21,11 +24,11 @@ class DatabaseStore implements Store
     protected $connection;
 
     /**
-     * The encrypter instance.
+     * The database connection instance that should be used to manage locks.
      *
-     * @var \Illuminate\Contracts\Encryption\Encrypter
+     * @var \Illuminate\Database\ConnectionInterface
      */
-    protected $encrypter;
+    protected $lockConnection;
 
     /**
      * The name of the cache table.
@@ -41,22 +44,41 @@ class DatabaseStore implements Store
      */
     protected $prefix;
 
+    /**
+     * The name of the cache locks table.
+     *
+     * @var string
+     */
+    protected $lockTable;
+
+    /**
+     * An array representation of the lock lottery odds.
+     *
+     * @var array
+     */
+    protected $lockLottery;
+
     /**
      * Create a new database store.
      *
      * @param  \Illuminate\Database\ConnectionInterface  $connection
-     * @param  \Illuminate\Contracts\Encryption\Encrypter  $encrypter
      * @param  string  $table
      * @param  string  $prefix
+     * @param  string  $lockTable
+     * @param  array  $lockLottery
      * @return void
      */
-    public function __construct(ConnectionInterface $connection, EncrypterContract $encrypter,
-                                $table, $prefix = '')
+    public function __construct(ConnectionInterface $connection,
+                                $table,
+                                $prefix = '',
+                                $lockTable = 'cache_locks',
+                                $lockLottery = [2, 100])
     {
         $this->table = $table;
         $this->prefix = $prefix;
-        $this->encrypter = $encrypter;
         $this->connection = $connection;
+        $this->lockTable = $lockTable;
+        $this->lockLottery = $lockLottery;
     }
 
     /**
@@ -83,38 +105,62 @@ class DatabaseStore implements Store
         // If this cache expiration date is past the current time, we will remove this
         // item from the cache. Then we will return a null value since the cache is
         // expired. We will use "Carbon" to make this comparison with the column.
-        if (Carbon::now()->getTimestamp() >= $cache->expiration) {
+        if ($this->currentTime() >= $cache->expiration) {
             $this->forget($key);
 
             return;
         }
 
-        return $this->encrypter->decrypt($cache->value);
+        return $this->unserialize($cache->value);
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
         $key = $this->prefix.$key;
-
-        // All of the cached values in the database are encrypted in case this is used
-        // as a session data store by the consumer. We'll also calculate the expire
-        // time and place that on the table so we will check it on our retrieval.
-        $value = $this->encrypter->encrypt($value);
-
-        $expiration = $this->getTime() + (int) ($minutes * 60);
+        $value = $this->serialize($value);
+        $expiration = $this->getTime() + $seconds;
 
         try {
-            $this->table()->insert(compact('key', 'value', 'expiration'));
+            return $this->table()->insert(compact('key', 'value', 'expiration'));
         } catch (Exception $e) {
-            $this->table()->where('key', $key)->update(compact('value', 'expiration'));
+            $result = $this->table()->where('key', $key)->update(compact('value', 'expiration'));
+
+            return $result > 0;
+        }
+    }
+
+    /**
+     * Store an item in the cache if the key doesn't exist.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function add($key, $value, $seconds)
+    {
+        $key = $this->prefix.$key;
+        $value = $this->serialize($value);
+        $expiration = $this->getTime() + $seconds;
+
+        try {
+            return $this->table()->insert(compact('key', 'value', 'expiration'));
+        } catch (QueryException $e) {
+            return $this->table()
+                ->where('key', $key)
+                ->where('expiration', '<=', $this->getTime())
+                ->update([
+                    'value' => $value,
+                    'expiration' => $expiration,
+                ]) >= 1;
         }
     }
 
@@ -122,7 +168,7 @@ class DatabaseStore implements Store
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function increment($key, $value = 1)
@@ -136,7 +182,7 @@ class DatabaseStore implements Store
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function decrement($key, $value = 1)
@@ -171,7 +217,7 @@ class DatabaseStore implements Store
 
             $cache = is_array($cache) ? (object) $cache : $cache;
 
-            $current = $this->encrypter->decrypt($cache->value);
+            $current = $this->unserialize($cache->value);
 
             // Here we'll call this callback function that was given to the function which
             // is used to either increment or decrement the function. We use a callback
@@ -186,7 +232,7 @@ class DatabaseStore implements Store
             // since database cache values are encrypted by default with secure storage
             // that can't be easily read. We will return the new value after storing.
             $this->table()->where('key', $prefixed)->update([
-                'value' => $this->encrypter->encrypt($new),
+                'value' => $this->serialize($new),
             ]);
 
             return $new;
@@ -200,19 +246,51 @@ class DatabaseStore implements Store
      */
     protected function getTime()
     {
-        return Carbon::now()->getTimestamp();
+        return $this->currentTime();
     }
 
     /**
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->put($key, $value, 5256000);
+        return $this->put($key, $value, 315360000);
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new DatabaseLock(
+            $this->lockConnection ?? $this->connection,
+            $this->lockTable,
+            $this->prefix.$name,
+            $seconds,
+            $owner,
+            $this->lockLottery
+        );
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
     }
 
     /**
@@ -235,7 +313,9 @@ class DatabaseStore implements Store
      */
     public function flush()
     {
-        return (bool) $this->table()->delete();
+        $this->table()->delete();
+
+        return true;
     }
 
     /**
@@ -259,13 +339,16 @@ class DatabaseStore implements Store
     }
 
     /**
-     * Get the encrypter instance.
+     * Specify the name of the connection that should be used to manage locks.
      *
-     * @return \Illuminate\Contracts\Encryption\Encrypter
+     * @param  \Illuminate\Database\ConnectionInterface  $connection
+     * @return $this
      */
-    public function getEncrypter()
+    public function setLockConnection($connection)
     {
-        return $this->encrypter;
+        $this->lockConnection = $connection;
+
+        return $this;
     }
 
     /**
@@ -277,4 +360,36 @@ class DatabaseStore implements Store
     {
         return $this->prefix;
     }
+
+    /**
+     * Serialize the given value.
+     *
+     * @param  mixed  $value
+     * @return string
+     */
+    protected function serialize($value)
+    {
+        $result = serialize($value);
+
+        if ($this->connection instanceof PostgresConnection && str_contains($result, "\0")) {
+            $result = base64_encode($result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Unserialize the given value.
+     *
+     * @param  string  $value
+     * @return mixed
+     */
+    protected function unserialize($value)
+    {
+        if ($this->connection instanceof PostgresConnection && ! Str::contains($value, [':', ';'])) {
+            $value = base64_decode($value);
+        }
+
+        return unserialize($value);
+    }
 }

vendor/laravel/framework/src/Illuminate/Cache/DynamoDbLock.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class DynamoDbLock extends Lock
+{
+    /**
+     * The DynamoDB client instance.
+     *
+     * @var \Illuminate\Cache\DynamoDbStore
+     */
+    protected $dynamo;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Cache\DynamoDbStore  $dynamo
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct(DynamoDbStore $dynamo, $name, $seconds, $owner = null)
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->dynamo = $dynamo;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        if ($this->seconds > 0) {
+            return $this->dynamo->add($this->name, $this->owner, $this->seconds);
+        } else {
+            return $this->dynamo->add($this->name, $this->owner, 86400);
+        }
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        if ($this->isOwnedByCurrentProcess()) {
+            return $this->dynamo->forget($this->name);
+        }
+
+        return false;
+    }
+
+    /**
+     * Release this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        $this->dynamo->forget($this->name);
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return mixed
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->dynamo->get($this->name);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/DynamoDbStore.php

@@ -0,0 +1,538 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Aws\DynamoDb\DynamoDbClient;
+use Aws\DynamoDb\Exception\DynamoDbException;
+use Illuminate\Contracts\Cache\LockProvider;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\InteractsWithTime;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+class DynamoDbStore implements LockProvider, Store
+{
+    use InteractsWithTime;
+
+    /**
+     * The DynamoDB client instance.
+     *
+     * @var \Aws\DynamoDb\DynamoDbClient
+     */
+    protected $dynamo;
+
+    /**
+     * The table name.
+     *
+     * @var string
+     */
+    protected $table;
+
+    /**
+     * The name of the attribute that should hold the key.
+     *
+     * @var string
+     */
+    protected $keyAttribute;
+
+    /**
+     * The name of the attribute that should hold the value.
+     *
+     * @var string
+     */
+    protected $valueAttribute;
+
+    /**
+     * The name of the attribute that should hold the expiration timestamp.
+     *
+     * @var string
+     */
+    protected $expirationAttribute;
+
+    /**
+     * A string that should be prepended to keys.
+     *
+     * @var string
+     */
+    protected $prefix;
+
+    /**
+     * Create a new store instance.
+     *
+     * @param  \Aws\DynamoDb\DynamoDbClient  $dynamo
+     * @param  string  $table
+     * @param  string  $keyAttribute
+     * @param  string  $valueAttribute
+     * @param  string  $expirationAttribute
+     * @param  string  $prefix
+     * @return void
+     */
+    public function __construct(DynamoDbClient $dynamo,
+                                $table,
+                                $keyAttribute = 'key',
+                                $valueAttribute = 'value',
+                                $expirationAttribute = 'expires_at',
+                                $prefix = '')
+    {
+        $this->table = $table;
+        $this->dynamo = $dynamo;
+        $this->keyAttribute = $keyAttribute;
+        $this->valueAttribute = $valueAttribute;
+        $this->expirationAttribute = $expirationAttribute;
+
+        $this->setPrefix($prefix);
+    }
+
+    /**
+     * Retrieve an item from the cache by key.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function get($key)
+    {
+        $response = $this->dynamo->getItem([
+            'TableName' => $this->table,
+            'ConsistentRead' => false,
+            'Key' => [
+                $this->keyAttribute => [
+                    'S' => $this->prefix.$key,
+                ],
+            ],
+        ]);
+
+        if (! isset($response['Item'])) {
+            return;
+        }
+
+        if ($this->isExpired($response['Item'])) {
+            return;
+        }
+
+        if (isset($response['Item'][$this->valueAttribute])) {
+            return $this->unserialize(
+                $response['Item'][$this->valueAttribute]['S'] ??
+                $response['Item'][$this->valueAttribute]['N'] ??
+                null
+            );
+        }
+    }
+
+    /**
+     * Retrieve multiple items from the cache by key.
+     *
+     * Items not found in the cache will have a null value.
+     *
+     * @param  array  $keys
+     * @return array
+     */
+    public function many(array $keys)
+    {
+        $prefixedKeys = array_map(function ($key) {
+            return $this->prefix.$key;
+        }, $keys);
+
+        $response = $this->dynamo->batchGetItem([
+            'RequestItems' => [
+                $this->table => [
+                    'ConsistentRead' => false,
+                    'Keys' => collect($prefixedKeys)->map(function ($key) {
+                        return [
+                            $this->keyAttribute => [
+                                'S' => $key,
+                            ],
+                        ];
+                    })->all(),
+                ],
+            ],
+        ]);
+
+        $now = Carbon::now();
+
+        return array_merge(collect(array_flip($keys))->map(function () {
+            //
+        })->all(), collect($response['Responses'][$this->table])->mapWithKeys(function ($response) use ($now) {
+            if ($this->isExpired($response, $now)) {
+                $value = null;
+            } else {
+                $value = $this->unserialize(
+                    $response[$this->valueAttribute]['S'] ??
+                    $response[$this->valueAttribute]['N'] ??
+                    null
+                );
+            }
+
+            return [Str::replaceFirst($this->prefix, '', $response[$this->keyAttribute]['S']) => $value];
+        })->all());
+    }
+
+    /**
+     * Determine if the given item is expired.
+     *
+     * @param  array  $item
+     * @param  \DateTimeInterface|null  $expiration
+     * @return bool
+     */
+    protected function isExpired(array $item, $expiration = null)
+    {
+        $expiration = $expiration ?: Carbon::now();
+
+        return isset($item[$this->expirationAttribute]) &&
+               $expiration->getTimestamp() >= $item[$this->expirationAttribute]['N'];
+    }
+
+    /**
+     * Store an item in the cache for a given number of seconds.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function put($key, $value, $seconds)
+    {
+        $this->dynamo->putItem([
+            'TableName' => $this->table,
+            'Item' => [
+                $this->keyAttribute => [
+                    'S' => $this->prefix.$key,
+                ],
+                $this->valueAttribute => [
+                    $this->type($value) => $this->serialize($value),
+                ],
+                $this->expirationAttribute => [
+                    'N' => (string) $this->toTimestamp($seconds),
+                ],
+            ],
+        ]);
+
+        return true;
+    }
+
+    /**
+     * Store multiple items in the cache for a given number of seconds.
+     *
+     * @param  array  $values
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function putMany(array $values, $seconds)
+    {
+        $expiration = $this->toTimestamp($seconds);
+
+        $this->dynamo->batchWriteItem([
+            'RequestItems' => [
+                $this->table => collect($values)->map(function ($value, $key) use ($expiration) {
+                    return [
+                        'PutRequest' => [
+                            'Item' => [
+                                $this->keyAttribute => [
+                                    'S' => $this->prefix.$key,
+                                ],
+                                $this->valueAttribute => [
+                                    $this->type($value) => $this->serialize($value),
+                                ],
+                                $this->expirationAttribute => [
+                                    'N' => (string) $expiration,
+                                ],
+                            ],
+                        ],
+                    ];
+                })->values()->all(),
+            ],
+        ]);
+
+        return true;
+    }
+
+    /**
+     * Store an item in the cache if the key doesn't exist.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function add($key, $value, $seconds)
+    {
+        try {
+            $this->dynamo->putItem([
+                'TableName' => $this->table,
+                'Item' => [
+                    $this->keyAttribute => [
+                        'S' => $this->prefix.$key,
+                    ],
+                    $this->valueAttribute => [
+                        $this->type($value) => $this->serialize($value),
+                    ],
+                    $this->expirationAttribute => [
+                        'N' => (string) $this->toTimestamp($seconds),
+                    ],
+                ],
+                'ConditionExpression' => 'attribute_not_exists(#key) OR #expires_at < :now',
+                'ExpressionAttributeNames' => [
+                    '#key' => $this->keyAttribute,
+                    '#expires_at' => $this->expirationAttribute,
+                ],
+                'ExpressionAttributeValues' => [
+                    ':now' => [
+                        'N' => (string) Carbon::now()->getTimestamp(),
+                    ],
+                ],
+            ]);
+
+            return true;
+        } catch (DynamoDbException $e) {
+            if (str_contains($e->getMessage(), 'ConditionalCheckFailed')) {
+                return false;
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Increment the value of an item in the cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return int|bool
+     */
+    public function increment($key, $value = 1)
+    {
+        try {
+            $response = $this->dynamo->updateItem([
+                'TableName' => $this->table,
+                'Key' => [
+                    $this->keyAttribute => [
+                        'S' => $this->prefix.$key,
+                    ],
+                ],
+                'ConditionExpression' => 'attribute_exists(#key) AND #expires_at > :now',
+                'UpdateExpression' => 'SET #value = #value + :amount',
+                'ExpressionAttributeNames' => [
+                    '#key' => $this->keyAttribute,
+                    '#value' => $this->valueAttribute,
+                    '#expires_at' => $this->expirationAttribute,
+                ],
+                'ExpressionAttributeValues' => [
+                    ':now' => [
+                        'N' => (string) Carbon::now()->getTimestamp(),
+                    ],
+                    ':amount' => [
+                        'N' => (string) $value,
+                    ],
+                ],
+                'ReturnValues' => 'UPDATED_NEW',
+            ]);
+
+            return (int) $response['Attributes'][$this->valueAttribute]['N'];
+        } catch (DynamoDbException $e) {
+            if (str_contains($e->getMessage(), 'ConditionalCheckFailed')) {
+                return false;
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Decrement the value of an item in the cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return int|bool
+     */
+    public function decrement($key, $value = 1)
+    {
+        try {
+            $response = $this->dynamo->updateItem([
+                'TableName' => $this->table,
+                'Key' => [
+                    $this->keyAttribute => [
+                        'S' => $this->prefix.$key,
+                    ],
+                ],
+                'ConditionExpression' => 'attribute_exists(#key) AND #expires_at > :now',
+                'UpdateExpression' => 'SET #value = #value - :amount',
+                'ExpressionAttributeNames' => [
+                    '#key' => $this->keyAttribute,
+                    '#value' => $this->valueAttribute,
+                    '#expires_at' => $this->expirationAttribute,
+                ],
+                'ExpressionAttributeValues' => [
+                    ':now' => [
+                        'N' => (string) Carbon::now()->getTimestamp(),
+                    ],
+                    ':amount' => [
+                        'N' => (string) $value,
+                    ],
+                ],
+                'ReturnValues' => 'UPDATED_NEW',
+            ]);
+
+            return (int) $response['Attributes'][$this->valueAttribute]['N'];
+        } catch (DynamoDbException $e) {
+            if (str_contains($e->getMessage(), 'ConditionalCheckFailed')) {
+                return false;
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Store an item in the cache indefinitely.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function forever($key, $value)
+    {
+        return $this->put($key, $value, Carbon::now()->addYears(5)->getTimestamp());
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new DynamoDbLock($this, $this->prefix.$name, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
+    }
+
+    /**
+     * Remove an item from the cache.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function forget($key)
+    {
+        $this->dynamo->deleteItem([
+            'TableName' => $this->table,
+            'Key' => [
+                $this->keyAttribute => [
+                    'S' => $this->prefix.$key,
+                ],
+            ],
+        ]);
+
+        return true;
+    }
+
+    /**
+     * Remove all items from the cache.
+     *
+     * @return bool
+     *
+     * @throws \RuntimeException
+     */
+    public function flush()
+    {
+        throw new RuntimeException('DynamoDb does not support flushing an entire table. Please create a new table.');
+    }
+
+    /**
+     * Get the UNIX timestamp for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @return int
+     */
+    protected function toTimestamp($seconds)
+    {
+        return $seconds > 0
+                    ? $this->availableAt($seconds)
+                    : Carbon::now()->getTimestamp();
+    }
+
+    /**
+     * Serialize the value.
+     *
+     * @param  mixed  $value
+     * @return mixed
+     */
+    protected function serialize($value)
+    {
+        return is_numeric($value) ? (string) $value : serialize($value);
+    }
+
+    /**
+     * Unserialize the value.
+     *
+     * @param  mixed  $value
+     * @return mixed
+     */
+    protected function unserialize($value)
+    {
+        if (filter_var($value, FILTER_VALIDATE_INT) !== false) {
+            return (int) $value;
+        }
+
+        if (is_numeric($value)) {
+            return (float) $value;
+        }
+
+        return unserialize($value);
+    }
+
+    /**
+     * Get the DynamoDB type for the given value.
+     *
+     * @param  mixed  $value
+     * @return string
+     */
+    protected function type($value)
+    {
+        return is_numeric($value) ? 'N' : 'S';
+    }
+
+    /**
+     * Get the cache key prefix.
+     *
+     * @return string
+     */
+    public function getPrefix()
+    {
+        return $this->prefix;
+    }
+
+    /**
+     * Set the cache key prefix.
+     *
+     * @param  string  $prefix
+     * @return void
+     */
+    public function setPrefix($prefix)
+    {
+        $this->prefix = ! empty($prefix) ? $prefix.':' : '';
+    }
+
+    /**
+     * Get the DynamoDb Client instance.
+     *
+     * @return \Aws\DynamoDb\DynamoDbClient
+     */
+    public function getClient()
+    {
+        return $this->dynamo;
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/Events/KeyWritten.php

@@ -12,26 +12,26 @@ class KeyWritten extends CacheEvent
     public $value;
 
     /**
-     * The number of minutes the key should be valid.
+     * The number of seconds the key should be valid.
      *
-     * @var int
+     * @var int|null
      */
-    public $minutes;
+    public $seconds;
 
     /**
      * Create a new event instance.
      *
      * @param  string  $key
      * @param  mixed  $value
-     * @param  int  $minutes
+     * @param  int|null  $seconds
      * @param  array  $tags
      * @return void
      */
-    public function __construct($key, $value, $minutes, $tags = [])
+    public function __construct($key, $value, $seconds = null, $tags = [])
     {
         parent::__construct($key, $tags);
 
         $this->value = $value;
-        $this->minutes = $minutes;
+        $this->seconds = $seconds;
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/FileStore.php

@@ -3,14 +3,16 @@
 namespace Illuminate\Cache;
 
 use Exception;
-use Carbon\Carbon;
-use Illuminate\Support\Arr;
+use Illuminate\Contracts\Cache\LockProvider;
 use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Filesystem\LockTimeoutException;
 use Illuminate\Filesystem\Filesystem;
+use Illuminate\Filesystem\LockableFile;
+use Illuminate\Support\InteractsWithTime;
 
-class FileStore implements Store
+class FileStore implements Store, LockProvider
 {
-    use RetrievesMultipleKeys;
+    use InteractsWithTime, HasCacheLock, RetrievesMultipleKeys;
 
     /**
      * The Illuminate Filesystem instance.
@@ -26,17 +28,26 @@ class FileStore implements Store
      */
     protected $directory;
 
+    /**
+     * Octal representation of the cache file permissions.
+     *
+     * @var int|null
+     */
+    protected $filePermission;
+
     /**
      * Create a new file cache store instance.
      *
      * @param  \Illuminate\Filesystem\Filesystem  $files
      * @param  string  $directory
+     * @param  int|null  $filePermission
      * @return void
      */
-    public function __construct(Filesystem $files, $directory)
+    public function __construct(Filesystem $files, $directory, $filePermission = null)
     {
         $this->files = $files;
         $this->directory = $directory;
+        $this->filePermission = $filePermission;
     }
 
     /**
@@ -47,24 +58,71 @@ class FileStore implements Store
      */
     public function get($key)
     {
-        return Arr::get($this->getPayload($key), 'data');
+        return $this->getPayload($key)['data'] ?? null;
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
         $this->ensureCacheDirectoryExists($path = $this->path($key));
 
-        $this->files->put(
-            $path, $this->expiration($minutes).serialize($value), true
+        $result = $this->files->put(
+            $path, $this->expiration($seconds).serialize($value), true
         );
+
+        if ($result !== false && $result > 0) {
+            $this->ensurePermissionsAreCorrect($path);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Store an item in the cache if the key doesn't exist.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
+     */
+    public function add($key, $value, $seconds)
+    {
+        $this->ensureCacheDirectoryExists($path = $this->path($key));
+
+        $file = new LockableFile($path, 'c+');
+
+        try {
+            $file->getExclusiveLock();
+        } catch (LockTimeoutException $e) {
+            $file->close();
+
+            return false;
+        }
+
+        $expire = $file->read(10);
+
+        if (empty($expire) || $this->currentTime() >= $expire) {
+            $file->truncate()
+                ->write($this->expiration($seconds).serialize($value))
+                ->close();
+
+            $this->ensurePermissionsAreCorrect($path);
+
+            return true;
+        }
+
+        $file->close();
+
+        return false;
     }
 
     /**
@@ -75,16 +133,38 @@ class FileStore implements Store
      */
     protected function ensureCacheDirectoryExists($path)
     {
-        if (! $this->files->exists(dirname($path))) {
-            $this->files->makeDirectory(dirname($path), 0777, true, true);
+        $directory = dirname($path);
+
+        if (! $this->files->exists($directory)) {
+            $this->files->makeDirectory($directory, 0777, true, true);
+
+            // We're creating two levels of directories (e.g. 7e/24), so we check them both...
+            $this->ensurePermissionsAreCorrect($directory);
+            $this->ensurePermissionsAreCorrect(dirname($directory));
         }
     }
 
+    /**
+     * Ensure the created node has the correct permissions.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    protected function ensurePermissionsAreCorrect($path)
+    {
+        if (is_null($this->filePermission) ||
+            intval($this->files->chmod($path), 8) == $this->filePermission) {
+            return;
+        }
+
+        $this->files->chmod($path, $this->filePermission);
+    }
+
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function increment($key, $value = 1)
@@ -92,7 +172,7 @@ class FileStore implements Store
         $raw = $this->getPayload($key);
 
         return tap(((int) $raw['data']) + $value, function ($newValue) use ($key, $raw) {
-            $this->put($key, $newValue, $raw['time']);
+            $this->put($key, $newValue, $raw['time'] ?? 0);
         });
     }
 
@@ -100,7 +180,7 @@ class FileStore implements Store
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function decrement($key, $value = 1)
@@ -112,12 +192,12 @@ class FileStore implements Store
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->put($key, $value, 0);
+        return $this->put($key, $value, 0);
     }
 
     /**
@@ -147,7 +227,9 @@ class FileStore implements Store
         }
 
         foreach ($this->files->directories($this->directory) as $directory) {
-            if (! $this->files->deleteDirectory($directory)) {
+            $deleted = $this->files->deleteDirectory($directory);
+
+            if (! $deleted || $this->files->exists($directory)) {
                 return false;
             }
         }
@@ -165,7 +247,7 @@ class FileStore implements Store
     {
         $path = $this->path($key);
 
-        // If the file doesn't exists, we obviously can't return the cache so we will
+        // If the file doesn't exist, we obviously cannot return the cache so we will
         // just return null. Otherwise, we'll get the contents of the file and get
         // the expiration UNIX timestamps from the start of the file's contents.
         try {
@@ -179,18 +261,24 @@ class FileStore implements Store
         // If the current time is greater than expiration timestamps we will delete
         // the file and return null. This helps clean up the old files and keeps
         // this directory much cleaner for us as old files aren't hanging out.
-        if (Carbon::now()->getTimestamp() >= $expire) {
+        if ($this->currentTime() >= $expire) {
             $this->forget($key);
 
             return $this->emptyPayload();
         }
 
-        $data = unserialize(substr($contents, 10));
+        try {
+            $data = unserialize(substr($contents, 10));
+        } catch (Exception $e) {
+            $this->forget($key);
 
-        // Next, we'll extract the number of minutes that are remaining for a cache
+            return $this->emptyPayload();
+        }
+
+        // Next, we'll extract the number of seconds that are remaining for a cache
         // so that we can properly retain the time for things like the increment
         // operation that may be performed on this cache on a later operation.
-        $time = ($expire - Carbon::now()->getTimestamp()) / 60;
+        $time = $expire - $this->currentTime();
 
         return compact('data', 'time');
     }
@@ -219,16 +307,16 @@ class FileStore implements Store
     }
 
     /**
-     * Get the expiration time based on the given minutes.
+     * Get the expiration time based on the given seconds.
      *
-     * @param  float|int  $minutes
+     * @param  int  $seconds
      * @return int
      */
-    protected function expiration($minutes)
+    protected function expiration($seconds)
     {
-        $time = Carbon::now()->getTimestamp() + (int) ($minutes * 60);
+        $time = $this->availableAt($seconds);
 
-        return $minutes === 0 || $time > 9999999999 ? 9999999999 : (int) $time;
+        return $seconds === 0 || $time > 9999999999 ? 9999999999 : $time;
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/HasCacheLock.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Illuminate\Cache;
+
+trait HasCacheLock
+{
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new CacheLock($this, $name, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Taylor Otwell
+
+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.

vendor/laravel/framework/src/Illuminate/Cache/Lock.php

@@ -0,0 +1,167 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Lock as LockContract;
+use Illuminate\Contracts\Cache\LockTimeoutException;
+use Illuminate\Support\InteractsWithTime;
+use Illuminate\Support\Str;
+
+abstract class Lock implements LockContract
+{
+    use InteractsWithTime;
+
+    /**
+     * The name of the lock.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The number of seconds the lock should be maintained.
+     *
+     * @var int
+     */
+    protected $seconds;
+
+    /**
+     * The scope identifier of this lock.
+     *
+     * @var string
+     */
+    protected $owner;
+
+    /**
+     * The number of milliseconds to wait before re-attempting to acquire a lock while blocking.
+     *
+     * @var int
+     */
+    protected $sleepMilliseconds = 250;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct($name, $seconds, $owner = null)
+    {
+        if (is_null($owner)) {
+            $owner = Str::random();
+        }
+
+        $this->name = $name;
+        $this->owner = $owner;
+        $this->seconds = $seconds;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    abstract public function acquire();
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    abstract public function release();
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return string
+     */
+    abstract protected function getCurrentOwner();
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @param  callable|null  $callback
+     * @return mixed
+     */
+    public function get($callback = null)
+    {
+        $result = $this->acquire();
+
+        if ($result && is_callable($callback)) {
+            try {
+                return $callback();
+            } finally {
+                $this->release();
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Attempt to acquire the lock for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @param  callable|null  $callback
+     * @return mixed
+     *
+     * @throws \Illuminate\Contracts\Cache\LockTimeoutException
+     */
+    public function block($seconds, $callback = null)
+    {
+        $starting = $this->currentTime();
+
+        while (! $this->acquire()) {
+            usleep($this->sleepMilliseconds * 1000);
+
+            if ($this->currentTime() - $seconds >= $starting) {
+                throw new LockTimeoutException;
+            }
+        }
+
+        if (is_callable($callback)) {
+            try {
+                return $callback();
+            } finally {
+                $this->release();
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns the current owner of the lock.
+     *
+     * @return string
+     */
+    public function owner()
+    {
+        return $this->owner;
+    }
+
+    /**
+     * Determines whether this lock is allowed to release the lock in the driver.
+     *
+     * @return bool
+     */
+    protected function isOwnedByCurrentProcess()
+    {
+        return $this->getCurrentOwner() === $this->owner;
+    }
+
+    /**
+     * Specify the number of milliseconds to sleep in between blocked lock acquisition attempts.
+     *
+     * @param  int  $milliseconds
+     * @return $this
+     */
+    public function betweenBlockedAttemptsSleepFor($milliseconds)
+    {
+        $this->sleepMilliseconds = $milliseconds;
+
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/LuaScripts.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class LuaScripts
+{
+    /**
+     * Get the Lua script to atomically release a lock.
+     *
+     * KEYS[1] - The name of the lock
+     * ARGV[1] - The owner key of the lock instance trying to release it
+     *
+     * @return string
+     */
+    public static function releaseLock()
+    {
+        return <<<'LUA'
+if redis.call("get",KEYS[1]) == ARGV[1] then
+    return redis.call("del",KEYS[1])
+else
+    return 0
+end
+LUA;
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/MemcachedConnector.php

@@ -47,7 +47,7 @@ class MemcachedConnector
     {
         $memcached = $this->createMemcachedInstance($connectionId);
 
-        if (count($credentials) == 2) {
+        if (count($credentials) === 2) {
             $this->setCredentials($memcached, $credentials);
         }
 
@@ -78,7 +78,7 @@ class MemcachedConnector
      */
     protected function setCredentials($memcached, $credentials)
     {
-        list($username, $password) = $credentials;
+        [$username, $password] = $credentials;
 
         $memcached->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
 

vendor/laravel/framework/src/Illuminate/Cache/MemcachedLock.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class MemcachedLock extends Lock
+{
+    /**
+     * The Memcached instance.
+     *
+     * @var \Memcached
+     */
+    protected $memcached;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Memcached  $memcached
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct($memcached, $name, $seconds, $owner = null)
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->memcached = $memcached;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        return $this->memcached->add(
+            $this->name, $this->owner, $this->seconds
+        );
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        if ($this->isOwnedByCurrentProcess()) {
+            return $this->memcached->delete($this->name);
+        }
+
+        return false;
+    }
+
+    /**
+     * Releases this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        $this->memcached->delete($this->name);
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return mixed
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->memcached->get($this->name);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/MemcachedStore.php

@@ -2,13 +2,15 @@
 
 namespace Illuminate\Cache;
 
+use Illuminate\Contracts\Cache\LockProvider;
+use Illuminate\Support\InteractsWithTime;
 use Memcached;
-use Carbon\Carbon;
 use ReflectionMethod;
-use Illuminate\Contracts\Cache\Store;
 
-class MemcachedStore extends TaggableStore implements Store
+class MemcachedStore extends TaggableStore implements LockProvider
 {
+    use InteractsWithTime;
+
     /**
      * The Memcached instance.
      *
@@ -34,7 +36,7 @@ class MemcachedStore extends TaggableStore implements Store
      * Create a new Memcached store.
      *
      * @param  \Memcached  $memcached
-     * @param  string      $prefix
+     * @param  string  $prefix
      * @return void
      */
     public function __construct($memcached, $prefix = '')
@@ -91,26 +93,28 @@ class MemcachedStore extends TaggableStore implements Store
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
-        $this->memcached->set($this->prefix.$key, $value, $this->toTimestamp($minutes));
+        return $this->memcached->set(
+            $this->prefix.$key, $value, $this->calculateExpiration($seconds)
+        );
     }
 
     /**
-     * Store multiple items in the cache for a given number of minutes.
+     * Store multiple items in the cache for a given number of seconds.
      *
      * @param  array  $values
-     * @param  float|int  $minutes
-     * @return void
+     * @param  int  $seconds
+     * @return bool
      */
-    public function putMany(array $values, $minutes)
+    public function putMany(array $values, $seconds)
     {
         $prefixedValues = [];
 
@@ -118,27 +122,31 @@ class MemcachedStore extends TaggableStore implements Store
             $prefixedValues[$this->prefix.$key] = $value;
         }
 
-        $this->memcached->setMulti($prefixedValues, $this->toTimestamp($minutes));
+        return $this->memcached->setMulti(
+            $prefixedValues, $this->calculateExpiration($seconds)
+        );
     }
 
     /**
      * Store an item in the cache if the key doesn't exist.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
+     * @param  mixed  $value
+     * @param  int  $seconds
      * @return bool
      */
-    public function add($key, $value, $minutes)
+    public function add($key, $value, $seconds)
     {
-        return $this->memcached->add($this->prefix.$key, $value, $this->toTimestamp($minutes));
+        return $this->memcached->add(
+            $this->prefix.$key, $value, $this->calculateExpiration($seconds)
+        );
     }
 
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function increment($key, $value = 1)
@@ -150,7 +158,7 @@ class MemcachedStore extends TaggableStore implements Store
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int|bool
      */
     public function decrement($key, $value = 1)
@@ -162,12 +170,37 @@ class MemcachedStore extends TaggableStore implements Store
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->put($key, $value, 0);
+        return $this->put($key, $value, 0);
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new MemcachedLock($this->memcached, $this->prefix.$name, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
     }
 
     /**
@@ -192,14 +225,25 @@ class MemcachedStore extends TaggableStore implements Store
     }
 
     /**
-     * Get the UNIX timestamp for the given number of minutes.
+     * Get the expiration time of the key.
      *
-     * @param  int  $minutes
+     * @param  int  $seconds
      * @return int
      */
-    protected function toTimestamp($minutes)
+    protected function calculateExpiration($seconds)
     {
-        return $minutes > 0 ? Carbon::now()->addSeconds($minutes * 60)->getTimestamp() : 0;
+        return $this->toTimestamp($seconds);
+    }
+
+    /**
+     * Get the UNIX timestamp for the given number of seconds.
+     *
+     * @param  int  $seconds
+     * @return int
+     */
+    protected function toTimestamp($seconds)
+    {
+        return $seconds > 0 ? $this->availableAt($seconds) : 0;
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/NoLock.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class NoLock extends Lock
+{
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        return true;
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        return true;
+    }
+
+    /**
+     * Releases this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        //
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return mixed
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->owner;
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/NullStore.php

@@ -2,24 +2,17 @@
 
 namespace Illuminate\Cache;
 
-use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Cache\LockProvider;
 
-class NullStore extends TaggableStore implements Store
+class NullStore extends TaggableStore implements LockProvider
 {
     use RetrievesMultipleKeys;
 
-    /**
-     * The array of stored values.
-     *
-     * @var array
-     */
-    protected $storage = [];
-
     /**
      * Retrieve an item from the cache by key.
      *
      * @param  string  $key
-     * @return mixed
+     * @return void
      */
     public function get($key)
     {
@@ -27,63 +20,88 @@ class NullStore extends TaggableStore implements Store
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
-        //
+        return false;
     }
 
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return int
+     * @param  mixed  $value
+     * @return bool
      */
     public function increment($key, $value = 1)
     {
-        //
+        return false;
     }
 
     /**
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return int
+     * @param  mixed  $value
+     * @return bool
      */
     public function decrement($key, $value = 1)
     {
-        //
+        return false;
     }
 
     /**
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        //
+        return false;
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        return new NoLock($name, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
     }
 
     /**
      * Remove an item from the cache.
      *
      * @param  string  $key
-     * @return void
+     * @return bool
      */
     public function forget($key)
     {
-        //
+        return true;
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/PhpRedisLock.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Illuminate\Cache;
+
+use Illuminate\Redis\Connections\PhpRedisConnection;
+
+class PhpRedisLock extends RedisLock
+{
+    /**
+     * Create a new phpredis lock instance.
+     *
+     * @param  \Illuminate\Redis\Connections\PhpRedisConnection  $redis
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct(PhpRedisConnection $redis, string $name, int $seconds, ?string $owner = null)
+    {
+        parent::__construct($redis, $name, $seconds, $owner);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function release()
+    {
+        return (bool) $this->redis->eval(
+            LuaScripts::releaseLock(),
+            1,
+            $this->name,
+            ...$this->redis->pack([$this->owner])
+        );
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/RateLimiter.php

@@ -2,11 +2,14 @@
 
 namespace Illuminate\Cache;
 
-use Carbon\Carbon;
+use Closure;
 use Illuminate\Contracts\Cache\Repository as Cache;
+use Illuminate\Support\InteractsWithTime;
 
 class RateLimiter
 {
+    use InteractsWithTime;
+
     /**
      * The cache store implementation.
      *
@@ -14,6 +17,13 @@ class RateLimiter
      */
     protected $cache;
 
+    /**
+     * The configured limit object resolvers.
+     *
+     * @var array
+     */
+    protected $limiters = [];
+
     /**
      * Create a new rate limiter instance.
      *
@@ -25,57 +35,95 @@ class RateLimiter
         $this->cache = $cache;
     }
 
+    /**
+     * Register a named limiter configuration.
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    public function for(string $name, Closure $callback)
+    {
+        $this->limiters[$name] = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Get the given named rate limiter.
+     *
+     * @param  string  $name
+     * @return \Closure
+     */
+    public function limiter(string $name)
+    {
+        return $this->limiters[$name] ?? null;
+    }
+
+    /**
+     * Attempts to execute a callback if it's not limited.
+     *
+     * @param  string  $key
+     * @param  int  $maxAttempts
+     * @param  \Closure  $callback
+     * @param  int  $decaySeconds
+     * @return mixed
+     */
+    public function attempt($key, $maxAttempts, Closure $callback, $decaySeconds = 60)
+    {
+        if ($this->tooManyAttempts($key, $maxAttempts)) {
+            return false;
+        }
+
+        return tap($callback() ?: true, function () use ($key, $decaySeconds) {
+            $this->hit($key, $decaySeconds);
+        });
+    }
+
     /**
      * Determine if the given key has been "accessed" too many times.
      *
      * @param  string  $key
      * @param  int  $maxAttempts
-     * @param  float|int  $decayMinutes
      * @return bool
      */
-    public function tooManyAttempts($key, $maxAttempts, $decayMinutes = 1)
+    public function tooManyAttempts($key, $maxAttempts)
     {
-        if ($this->cache->has($key.':lockout')) {
-            return true;
-        }
-
         if ($this->attempts($key) >= $maxAttempts) {
-            $this->lockout($key, $decayMinutes);
+            if ($this->cache->has($this->cleanRateLimiterKey($key).':timer')) {
+                return true;
+            }
 
             $this->resetAttempts($key);
-
-            return true;
         }
 
         return false;
     }
 
-    /**
-     * Add the lockout key to the cache.
-     *
-     * @param  string  $key
-     * @param  int  $decayMinutes
-     * @return void
-     */
-    protected function lockout($key, $decayMinutes)
-    {
-        $this->cache->add(
-            $key.':lockout', Carbon::now()->getTimestamp() + ($decayMinutes * 60), $decayMinutes
-        );
-    }
-
     /**
      * Increment the counter for a given key for a given decay time.
      *
      * @param  string  $key
-     * @param  float|int  $decayMinutes
+     * @param  int  $decaySeconds
      * @return int
      */
-    public function hit($key, $decayMinutes = 1)
+    public function hit($key, $decaySeconds = 60)
     {
-        $this->cache->add($key, 0, $decayMinutes);
+        $key = $this->cleanRateLimiterKey($key);
 
-        return (int) $this->cache->increment($key);
+        $this->cache->add(
+            $key.':timer', $this->availableAt($decaySeconds), $decaySeconds
+        );
+
+        $added = $this->cache->add($key, 0, $decaySeconds);
+
+        $hits = (int) $this->cache->increment($key);
+
+        if (! $added && $hits == 1) {
+            $this->cache->put($key, 1, $decaySeconds);
+        }
+
+        return $hits;
     }
 
     /**
@@ -86,6 +134,8 @@ class RateLimiter
      */
     public function attempts($key)
     {
+        $key = $this->cleanRateLimiterKey($key);
+
         return $this->cache->get($key, 0);
     }
 
@@ -97,9 +147,27 @@ class RateLimiter
      */
     public function resetAttempts($key)
     {
+        $key = $this->cleanRateLimiterKey($key);
+
         return $this->cache->forget($key);
     }
 
+    /**
+     * Get the number of retries left for the given key.
+     *
+     * @param  string  $key
+     * @param  int  $maxAttempts
+     * @return int
+     */
+    public function remaining($key, $maxAttempts)
+    {
+        $key = $this->cleanRateLimiterKey($key);
+
+        $attempts = $this->attempts($key);
+
+        return $maxAttempts - $attempts;
+    }
+
     /**
      * Get the number of retries left for the given key.
      *
@@ -109,22 +177,22 @@ class RateLimiter
      */
     public function retriesLeft($key, $maxAttempts)
     {
-        $attempts = $this->attempts($key);
-
-        return $maxAttempts - $attempts;
+        return $this->remaining($key, $maxAttempts);
     }
 
     /**
-     * Clear the hits and lockout for the given key.
+     * Clear the hits and lockout timer for the given key.
      *
      * @param  string  $key
      * @return void
      */
     public function clear($key)
     {
+        $key = $this->cleanRateLimiterKey($key);
+
         $this->resetAttempts($key);
 
-        $this->cache->forget($key.':lockout');
+        $this->cache->forget($key.':timer');
     }
 
     /**
@@ -135,6 +203,19 @@ class RateLimiter
      */
     public function availableIn($key)
     {
-        return $this->cache->get($key.':lockout') - Carbon::now()->getTimestamp();
+        $key = $this->cleanRateLimiterKey($key);
+
+        return max(0, $this->cache->get($key.':timer') - $this->currentTime());
+    }
+
+    /**
+     * Clean the rate limiter key from unicode characters.
+     *
+     * @param  string  $key
+     * @return string
+     */
+    public function cleanRateLimiterKey($key)
+    {
+        return preg_replace('/&([a-z])[a-z]+;/i', '$1', htmlentities($key));
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/RateLimiting/GlobalLimit.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Illuminate\Cache\RateLimiting;
+
+class GlobalLimit extends Limit
+{
+    /**
+     * Create a new limit instance.
+     *
+     * @param  int  $maxAttempts
+     * @param  int  $decayMinutes
+     * @return void
+     */
+    public function __construct(int $maxAttempts, int $decayMinutes = 1)
+    {
+        parent::__construct('', $maxAttempts, $decayMinutes);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/RateLimiting/Limit.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Illuminate\Cache\RateLimiting;
+
+class Limit
+{
+    /**
+     * The rate limit signature key.
+     *
+     * @var mixed
+     */
+    public $key;
+
+    /**
+     * The maximum number of attempts allowed within the given number of minutes.
+     *
+     * @var int
+     */
+    public $maxAttempts;
+
+    /**
+     * The number of minutes until the rate limit is reset.
+     *
+     * @var int
+     */
+    public $decayMinutes;
+
+    /**
+     * The response generator callback.
+     *
+     * @var callable
+     */
+    public $responseCallback;
+
+    /**
+     * Create a new limit instance.
+     *
+     * @param  mixed  $key
+     * @param  int  $maxAttempts
+     * @param  int  $decayMinutes
+     * @return void
+     */
+    public function __construct($key = '', int $maxAttempts = 60, int $decayMinutes = 1)
+    {
+        $this->key = $key;
+        $this->maxAttempts = $maxAttempts;
+        $this->decayMinutes = $decayMinutes;
+    }
+
+    /**
+     * Create a new rate limit.
+     *
+     * @param  int  $maxAttempts
+     * @return static
+     */
+    public static function perMinute($maxAttempts)
+    {
+        return new static('', $maxAttempts);
+    }
+
+    /**
+     * Create a new rate limit using minutes as decay time.
+     *
+     * @param  int  $decayMinutes
+     * @param  int  $maxAttempts
+     * @return static
+     */
+    public static function perMinutes($decayMinutes, $maxAttempts)
+    {
+        return new static('', $maxAttempts, $decayMinutes);
+    }
+
+    /**
+     * Create a new rate limit using hours as decay time.
+     *
+     * @param  int  $maxAttempts
+     * @param  int  $decayHours
+     * @return static
+     */
+    public static function perHour($maxAttempts, $decayHours = 1)
+    {
+        return new static('', $maxAttempts, 60 * $decayHours);
+    }
+
+    /**
+     * Create a new rate limit using days as decay time.
+     *
+     * @param  int  $maxAttempts
+     * @param  int  $decayDays
+     * @return static
+     */
+    public static function perDay($maxAttempts, $decayDays = 1)
+    {
+        return new static('', $maxAttempts, 60 * 24 * $decayDays);
+    }
+
+    /**
+     * Create a new unlimited rate limit.
+     *
+     * @return static
+     */
+    public static function none()
+    {
+        return new Unlimited;
+    }
+
+    /**
+     * Set the key of the rate limit.
+     *
+     * @param  mixed  $key
+     * @return $this
+     */
+    public function by($key)
+    {
+        $this->key = $key;
+
+        return $this;
+    }
+
+    /**
+     * Set the callback that should generate the response when the limit is exceeded.
+     *
+     * @param  callable  $callback
+     * @return $this
+     */
+    public function response(callable $callback)
+    {
+        $this->responseCallback = $callback;
+
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/RateLimiting/Unlimited.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Illuminate\Cache\RateLimiting;
+
+class Unlimited extends GlobalLimit
+{
+    /**
+     * Create a new limit instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        parent::__construct(PHP_INT_MAX);
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/RedisLock.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Illuminate\Cache;
+
+class RedisLock extends Lock
+{
+    /**
+     * The Redis factory implementation.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    protected $redis;
+
+    /**
+     * Create a new lock instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $redis
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return void
+     */
+    public function __construct($redis, $name, $seconds, $owner = null)
+    {
+        parent::__construct($name, $seconds, $owner);
+
+        $this->redis = $redis;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        if ($this->seconds > 0) {
+            return $this->redis->set($this->name, $this->owner, 'EX', $this->seconds, 'NX') == true;
+        } else {
+            return $this->redis->setnx($this->name, $this->owner) === 1;
+        }
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @return bool
+     */
+    public function release()
+    {
+        return (bool) $this->redis->eval(LuaScripts::releaseLock(), 1, $this->name, $this->owner);
+    }
+
+    /**
+     * Releases this lock in disregard of ownership.
+     *
+     * @return void
+     */
+    public function forceRelease()
+    {
+        $this->redis->del($this->name);
+    }
+
+    /**
+     * Returns the owner value written into the driver for this lock.
+     *
+     * @return string
+     */
+    protected function getCurrentOwner()
+    {
+        return $this->redis->get($this->name);
+    }
+
+    /**
+     * Get the name of the Redis connection being used to manage the lock.
+     *
+     * @return string
+     */
+    public function getConnectionName()
+    {
+        return $this->redis->getName();
+    }
+}

vendor/laravel/framework/src/Illuminate/Cache/RedisStore.php

@@ -2,10 +2,11 @@
 
 namespace Illuminate\Cache;
 
-use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Cache\LockProvider;
 use Illuminate\Contracts\Redis\Factory as Redis;
+use Illuminate\Redis\Connections\PhpRedisConnection;
 
-class RedisStore extends TaggableStore implements Store
+class RedisStore extends TaggableStore implements LockProvider
 {
     /**
      * The Redis factory implementation.
@@ -22,12 +23,19 @@ class RedisStore extends TaggableStore implements Store
     protected $prefix;
 
     /**
-     * The Redis connection that should be used.
+     * The Redis connection instance that should be used to manage locks.
      *
      * @var string
      */
     protected $connection;
 
+    /**
+     * The name of the connection that should be used for locks.
+     *
+     * @var string
+     */
+    protected $lockConnection;
+
     /**
      * Create a new Redis store.
      *
@@ -80,52 +88,58 @@ class RedisStore extends TaggableStore implements Store
     }
 
     /**
-     * Store an item in the cache for a given number of minutes.
+     * Store an item in the cache for a given number of seconds.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  int  $seconds
+     * @return bool
      */
-    public function put($key, $value, $minutes)
+    public function put($key, $value, $seconds)
     {
-        $this->connection()->setex(
-            $this->prefix.$key, (int) max(1, $minutes * 60), $this->serialize($value)
+        return (bool) $this->connection()->setex(
+            $this->prefix.$key, (int) max(1, $seconds), $this->serialize($value)
         );
     }
 
     /**
-     * Store multiple items in the cache for a given number of minutes.
+     * Store multiple items in the cache for a given number of seconds.
      *
      * @param  array  $values
-     * @param  float|int  $minutes
-     * @return void
+     * @param  int  $seconds
+     * @return bool
      */
-    public function putMany(array $values, $minutes)
+    public function putMany(array $values, $seconds)
     {
         $this->connection()->multi();
 
+        $manyResult = null;
+
         foreach ($values as $key => $value) {
-            $this->put($key, $value, $minutes);
+            $result = $this->put($key, $value, $seconds);
+
+            $manyResult = is_null($manyResult) ? $result : $result && $manyResult;
         }
 
         $this->connection()->exec();
+
+        return $manyResult ?: false;
     }
 
     /**
      * Store an item in the cache if the key doesn't exist.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  float|int  $minutes
+     * @param  mixed  $value
+     * @param  int  $seconds
      * @return bool
      */
-    public function add($key, $value, $minutes)
+    public function add($key, $value, $seconds)
     {
         $lua = "return redis.call('exists',KEYS[1])<1 and redis.call('setex',KEYS[1],ARGV[2],ARGV[1])";
 
         return (bool) $this->connection()->eval(
-            $lua, 1, $this->prefix.$key, $this->serialize($value), (int) max(1, $minutes * 60)
+            $lua, 1, $this->prefix.$key, $this->serialize($value), (int) max(1, $seconds)
         );
     }
 
@@ -133,7 +147,7 @@ class RedisStore extends TaggableStore implements Store
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function increment($key, $value = 1)
@@ -145,7 +159,7 @@ class RedisStore extends TaggableStore implements Store
      * Decrement the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return int
      */
     public function decrement($key, $value = 1)
@@ -157,12 +171,45 @@ class RedisStore extends TaggableStore implements Store
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->connection()->set($this->prefix.$key, $this->serialize($value));
+        return (bool) $this->connection()->set($this->prefix.$key, $this->serialize($value));
+    }
+
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        $lockName = $this->prefix.$name;
+
+        $lockConnection = $this->lockConnection();
+
+        if ($lockConnection instanceof PhpRedisConnection) {
+            return new PhpRedisLock($lockConnection, $lockName, $seconds, $owner);
+        }
+
+        return new RedisLock($lockConnection, $lockName, $seconds, $owner);
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        return $this->lock($name, 0, $owner);
     }
 
     /**
@@ -204,7 +251,7 @@ class RedisStore extends TaggableStore implements Store
     /**
      * Get the Redis connection instance.
      *
-     * @return \Predis\ClientInterface
+     * @return \Illuminate\Redis\Connections\Connection
      */
     public function connection()
     {
@@ -212,7 +259,17 @@ class RedisStore extends TaggableStore implements Store
     }
 
     /**
-     * Set the connection name to be used.
+     * Get the Redis connection instance that should be used to manage locks.
+     *
+     * @return \Illuminate\Redis\Connections\Connection
+     */
+    public function lockConnection()
+    {
+        return $this->redis->connection($this->lockConnection ?? $this->connection);
+    }
+
+    /**
+     * Specify the name of the connection that should be used to store data.
      *
      * @param  string  $connection
      * @return void
@@ -222,6 +279,19 @@ class RedisStore extends TaggableStore implements Store
         $this->connection = $connection;
     }
 
+    /**
+     * Specify the name of the connection that should be used to manage locks.
+     *
+     * @param  string  $connection
+     * @return $this
+     */
+    public function setLockConnection($connection)
+    {
+        $this->lockConnection = $connection;
+
+        return $this;
+    }
+
     /**
      * Get the Redis database instance.
      *
@@ -261,7 +331,7 @@ class RedisStore extends TaggableStore implements Store
      */
     protected function serialize($value)
     {
-        return is_numeric($value) ? $value : serialize($value);
+        return is_numeric($value) && ! in_array($value, [INF, -INF]) && ! is_nan($value) ? $value : serialize($value);
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/RedisTaggedCache.php

@@ -10,6 +10,7 @@ class RedisTaggedCache extends TaggedCache
      * @var string
      */
     const REFERENCE_KEY_FOREVER = 'forever_ref';
+
     /**
      * Standard reference key.
      *
@@ -21,42 +22,76 @@ class RedisTaggedCache extends TaggedCache
      * Store an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  \DateTime|float|int  $minutes
-     * @return void
+     * @param  mixed  $value
+     * @param  \DateTimeInterface|\DateInterval|int|null  $ttl
+     * @return bool
      */
-    public function put($key, $value, $minutes = null)
+    public function put($key, $value, $ttl = null)
+    {
+        if ($ttl === null) {
+            return $this->forever($key, $value);
+        }
+
+        $this->pushStandardKeys($this->tags->getNamespace(), $key);
+
+        return parent::put($key, $value, $ttl);
+    }
+
+    /**
+     * Increment the value of an item in the cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return int|bool
+     */
+    public function increment($key, $value = 1)
     {
         $this->pushStandardKeys($this->tags->getNamespace(), $key);
 
-        parent::put($key, $value, $minutes);
+        return parent::increment($key, $value);
+    }
+
+    /**
+     * Decrement the value of an item in the cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return int|bool
+     */
+    public function decrement($key, $value = 1)
+    {
+        $this->pushStandardKeys($this->tags->getNamespace(), $key);
+
+        return parent::decrement($key, $value);
     }
 
     /**
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
         $this->pushForeverKeys($this->tags->getNamespace(), $key);
 
-        parent::forever($key, $value);
+        return parent::forever($key, $value);
     }
 
     /**
      * Remove all items from the cache.
      *
-     * @return void
+     * @return bool
      */
     public function flush()
     {
         $this->deleteForeverKeys();
         $this->deleteStandardKeys();
 
-        parent::flush();
+        $this->tags->flush();
+
+        return true;
     }
 
     /**
@@ -143,13 +178,26 @@ class RedisTaggedCache extends TaggedCache
      */
     protected function deleteValues($referenceKey)
     {
-        $values = array_unique($this->store->connection()->smembers($referenceKey));
+        $cursor = $defaultCursorValue = '0';
 
-        if (count($values) > 0) {
-            foreach (array_chunk($values, 1000) as $valuesChunk) {
-                call_user_func_array([$this->store->connection(), 'del'], $valuesChunk);
+        do {
+            [$cursor, $valuesChunk] = $this->store->connection()->sscan(
+                $referenceKey, $cursor, ['match' => '*', 'count' => 1000]
+            );
+
+            // PhpRedis client returns false if set does not exist or empty. Array destruction
+            // on false stores null in each variable. If valuesChunk is null, it means that
+            // there were not results from the previously executed "sscan" Redis command.
+            if (is_null($valuesChunk)) {
+                break;
             }
-        }
+
+            $valuesChunk = array_unique($valuesChunk);
+
+            if (count($valuesChunk) > 0) {
+                $this->store->connection()->del(...$valuesChunk);
+            }
+        } while (((string) $cursor) !== $defaultCursorValue);
     }
 
     /**

vendor/laravel/framework/src/Illuminate/Cache/Repository.php

@@ -2,22 +2,27 @@
 
 namespace Illuminate\Cache;
 
-use Closure;
-use DateTime;
 use ArrayAccess;
-use Carbon\Carbon;
 use BadMethodCallException;
+use Closure;
+use DateTimeInterface;
 use Illuminate\Cache\Events\CacheHit;
-use Illuminate\Contracts\Cache\Store;
-use Illuminate\Cache\Events\KeyWritten;
 use Illuminate\Cache\Events\CacheMissed;
-use Illuminate\Support\Traits\Macroable;
 use Illuminate\Cache\Events\KeyForgotten;
-use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Cache\Events\KeyWritten;
 use Illuminate\Contracts\Cache\Repository as CacheContract;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\InteractsWithTime;
+use Illuminate\Support\Traits\Macroable;
 
-class Repository implements CacheContract, ArrayAccess
+/**
+ * @mixin \Illuminate\Contracts\Cache\Store
+ */
+class Repository implements ArrayAccess, CacheContract
 {
+    use InteractsWithTime;
     use Macroable {
         __call as macroCall;
     }
@@ -37,11 +42,11 @@ class Repository implements CacheContract, ArrayAccess
     protected $events;
 
     /**
-     * The default number of minutes to store items.
+     * The default number of seconds to store items.
      *
-     * @var float|int
+     * @var int|null
      */
-    protected $default = 60;
+    protected $default = 3600;
 
     /**
      * Create a new cache repository instance.
@@ -60,19 +65,30 @@ class Repository implements CacheContract, ArrayAccess
      * @param  string  $key
      * @return bool
      */
-    public function has($key)
+    public function has($key): bool
     {
         return ! is_null($this->get($key));
     }
 
     /**
-     * Retrieve an item from the cache by key.
+     * Determine if an item doesn't exist in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $default
+     * @return bool
+     */
+    public function missing($key)
+    {
+        return ! $this->has($key);
+    }
+
+    /**
+     * Retrieve an item from the cache by key.
+     *
+     * @param  array|string  $key
+     * @param  mixed  $default
      * @return mixed
      */
-    public function get($key, $default = null)
+    public function get($key, $default = null): mixed
     {
         if (is_array($key)) {
             return $this->many($key);
@@ -113,6 +129,22 @@ class Repository implements CacheContract, ArrayAccess
         })->all();
     }
 
+    /**
+     * {@inheritdoc}
+     *
+     * @return iterable
+     */
+    public function getMultiple($keys, $default = null): iterable
+    {
+        $defaults = [];
+
+        foreach ($keys as $key) {
+            $defaults[$key] = $default;
+        }
+
+        return $this->many($defaults);
+    }
+
     /**
      * Handle a result for the "many" method.
      *
@@ -144,12 +176,12 @@ class Repository implements CacheContract, ArrayAccess
      * Retrieve an item from the cache and delete it.
      *
      * @param  string  $key
-     * @param  mixed   $default
+     * @param  mixed  $default
      * @return mixed
      */
     public function pull($key, $default = null)
     {
-        return tap($this->get($key, $default), function ($value) use ($key) {
+        return tap($this->get($key, $default), function () use ($key) {
             $this->forget($key);
         });
     }
@@ -157,72 +189,139 @@ class Repository implements CacheContract, ArrayAccess
     /**
      * Store an item in the cache.
      *
-     * @param  string  $key
-     * @param  mixed   $value
-     * @param  \DateTime|float|int  $minutes
-     * @return void
+     * @param  array|string  $key
+     * @param  mixed  $value
+     * @param  \DateTimeInterface|\DateInterval|int|null  $ttl
+     * @return bool
      */
-    public function put($key, $value, $minutes = null)
+    public function put($key, $value, $ttl = null)
     {
         if (is_array($key)) {
             return $this->putMany($key, $value);
         }
 
-        if (! is_null($minutes = $this->getMinutes($minutes))) {
-            $this->store->put($this->itemKey($key), $value, $minutes);
-
-            $this->event(new KeyWritten($key, $value, $minutes));
+        if ($ttl === null) {
+            return $this->forever($key, $value);
         }
+
+        $seconds = $this->getSeconds($ttl);
+
+        if ($seconds <= 0) {
+            return $this->forget($key);
+        }
+
+        $result = $this->store->put($this->itemKey($key), $value, $seconds);
+
+        if ($result) {
+            $this->event(new KeyWritten($key, $value, $seconds));
+        }
+
+        return $result;
     }
 
     /**
-     * Store multiple items in the cache for a given number of minutes.
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function set($key, $value, $ttl = null): bool
+    {
+        return $this->put($key, $value, $ttl);
+    }
+
+    /**
+     * Store multiple items in the cache for a given number of seconds.
      *
      * @param  array  $values
-     * @param  float|int  $minutes
-     * @return void
+     * @param  \DateTimeInterface|\DateInterval|int|null  $ttl
+     * @return bool
      */
-    public function putMany(array $values, $minutes)
+    public function putMany(array $values, $ttl = null)
     {
-        if (! is_null($minutes = $this->getMinutes($minutes))) {
-            $this->store->putMany($values, $minutes);
+        if ($ttl === null) {
+            return $this->putManyForever($values);
+        }
 
+        $seconds = $this->getSeconds($ttl);
+
+        if ($seconds <= 0) {
+            return $this->deleteMultiple(array_keys($values));
+        }
+
+        $result = $this->store->putMany($values, $seconds);
+
+        if ($result) {
             foreach ($values as $key => $value) {
-                $this->event(new KeyWritten($key, $value, $minutes));
+                $this->event(new KeyWritten($key, $value, $seconds));
             }
         }
+
+        return $result;
+    }
+
+    /**
+     * Store multiple items in the cache indefinitely.
+     *
+     * @param  array  $values
+     * @return bool
+     */
+    protected function putManyForever(array $values)
+    {
+        $result = true;
+
+        foreach ($values as $key => $value) {
+            if (! $this->forever($key, $value)) {
+                $result = false;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function setMultiple($values, $ttl = null): bool
+    {
+        return $this->putMany(is_array($values) ? $values : iterator_to_array($values), $ttl);
     }
 
     /**
      * Store an item in the cache if the key does not exist.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @param  \DateTime|float|int  $minutes
+     * @param  mixed  $value
+     * @param  \DateTimeInterface|\DateInterval|int|null  $ttl
      * @return bool
      */
-    public function add($key, $value, $minutes)
+    public function add($key, $value, $ttl = null)
     {
-        if (is_null($minutes = $this->getMinutes($minutes))) {
-            return false;
-        }
+        $seconds = null;
 
-        // If the store has an "add" method we will call the method on the store so it
-        // has a chance to override this logic. Some drivers better support the way
-        // this operation should work with a total "atomic" implementation of it.
-        if (method_exists($this->store, 'add')) {
-            return $this->store->add(
-                $this->itemKey($key), $value, $minutes
-            );
+        if ($ttl !== null) {
+            $seconds = $this->getSeconds($ttl);
+
+            if ($seconds <= 0) {
+                return false;
+            }
+
+            // If the store has an "add" method we will call the method on the store so it
+            // has a chance to override this logic. Some drivers better support the way
+            // this operation should work with a total "atomic" implementation of it.
+            if (method_exists($this->store, 'add')) {
+                return $this->store->add(
+                    $this->itemKey($key), $value, $seconds
+                );
+            }
         }
 
         // If the value did not exist in the cache, we will put the value in the cache
         // so it exists for subsequent requests. Then, we will return true so it is
         // easy to know if the value gets added. Otherwise, we will return false.
         if (is_null($this->get($key))) {
-            $this->put($key, $value, $minutes);
-
-            return true;
+            return $this->put($key, $value, $seconds);
         }
 
         return false;
@@ -256,44 +355,48 @@ class Repository implements CacheContract, ArrayAccess
      * Store an item in the cache indefinitely.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return bool
      */
     public function forever($key, $value)
     {
-        $this->store->forever($this->itemKey($key), $value);
+        $result = $this->store->forever($this->itemKey($key), $value);
 
-        $this->event(new KeyWritten($key, $value, 0));
+        if ($result) {
+            $this->event(new KeyWritten($key, $value));
+        }
+
+        return $result;
     }
 
     /**
-     * Get an item from the cache, or store the default value.
+     * Get an item from the cache, or execute the given Closure and store the result.
      *
      * @param  string  $key
-     * @param  \DateTime|float|int  $minutes
+     * @param  \Closure|\DateTimeInterface|\DateInterval|int|null  $ttl
      * @param  \Closure  $callback
      * @return mixed
      */
-    public function remember($key, $minutes, Closure $callback)
+    public function remember($key, $ttl, Closure $callback)
     {
         $value = $this->get($key);
 
         // If the item exists in the cache we will just return this immediately and if
         // not we will execute the given Closure and cache the result of that for a
-        // given number of minutes so it's available for all subsequent requests.
+        // given number of seconds so it's available for all subsequent requests.
         if (! is_null($value)) {
             return $value;
         }
 
-        $this->put($key, $value = $callback(), $minutes);
+        $this->put($key, $value = $callback(), value($ttl));
 
         return $value;
     }
 
     /**
-     * Get an item from the cache, or store the default value forever.
+     * Get an item from the cache, or execute the given Closure and store the result forever.
      *
-     * @param  string   $key
+     * @param  string  $key
      * @param  \Closure  $callback
      * @return mixed
      */
@@ -303,9 +406,9 @@ class Repository implements CacheContract, ArrayAccess
     }
 
     /**
-     * Get an item from the cache, or store the default value forever.
+     * Get an item from the cache, or execute the given Closure and store the result forever.
      *
-     * @param  string   $key
+     * @param  string  $key
      * @param  \Closure  $callback
      * @return mixed
      */
@@ -313,9 +416,9 @@ class Repository implements CacheContract, ArrayAccess
     {
         $value = $this->get($key);
 
-        // If the item exists in the cache we will just return this immediately and if
-        // not we will execute the given Closure and cache the result of that for a
-        // given number of minutes so it's available for all subsequent requests.
+        // If the item exists in the cache we will just return this immediately
+        // and if not we will execute the given Closure and cache the result
+        // of that forever so it is available for all subsequent requests.
         if (! is_null($value)) {
             return $value;
         }
@@ -333,11 +436,51 @@ class Repository implements CacheContract, ArrayAccess
      */
     public function forget($key)
     {
-        return tap($this->store->forget($this->itemKey($key)), function () use ($key) {
-            $this->event(new KeyForgotten($key));
+        return tap($this->store->forget($this->itemKey($key)), function ($result) use ($key) {
+            if ($result) {
+                $this->event(new KeyForgotten($key));
+            }
         });
     }
 
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function delete($key): bool
+    {
+        return $this->forget($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function deleteMultiple($keys): bool
+    {
+        $result = true;
+
+        foreach ($keys as $key) {
+            if (! $this->forget($key)) {
+                $result = false;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    public function clear(): bool
+    {
+        return $this->store->flush();
+    }
+
     /**
      * Begin executing a new tags operation if the store supports it.
      *
@@ -348,11 +491,11 @@ class Repository implements CacheContract, ArrayAccess
      */
     public function tags($names)
     {
-        if (! method_exists($this->store, 'tags')) {
+        if (! $this->supportsTags()) {
             throw new BadMethodCallException('This cache store does not support tagging.');
         }
 
-        $cache = $this->store->tags($names);
+        $cache = $this->store->tags(is_array($names) ? $names : func_get_args());
 
         if (! is_null($this->events)) {
             $cache->setEventDispatcher($this->events);
@@ -372,10 +515,37 @@ class Repository implements CacheContract, ArrayAccess
         return $key;
     }
 
+    /**
+     * Calculate the number of seconds for the given TTL.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $ttl
+     * @return int
+     */
+    protected function getSeconds($ttl)
+    {
+        $duration = $this->parseDateInterval($ttl);
+
+        if ($duration instanceof DateTimeInterface) {
+            $duration = Carbon::now()->diffInRealSeconds($duration, false);
+        }
+
+        return (int) ($duration > 0 ? $duration : 0);
+    }
+
+    /**
+     * Determine if the current store supports tags.
+     *
+     * @return bool
+     */
+    public function supportsTags()
+    {
+        return method_exists($this->store, 'tags');
+    }
+
     /**
      * Get the default cache time.
      *
-     * @return float|int
+     * @return int|null
      */
     public function getDefaultCacheTime()
     {
@@ -383,14 +553,14 @@ class Repository implements CacheContract, ArrayAccess
     }
 
     /**
-     * Set the default cache time in minutes.
+     * Set the default cache time in seconds.
      *
-     * @param  float|int  $minutes
+     * @param  int|null  $seconds
      * @return $this
      */
-    public function setDefaultCacheTime($minutes)
+    public function setDefaultCacheTime($seconds)
     {
-        $this->default = $minutes;
+        $this->default = $seconds;
 
         return $this;
     }
@@ -408,14 +578,22 @@ class Repository implements CacheContract, ArrayAccess
     /**
      * Fire an event for this cache instance.
      *
-     * @param  string  $event
+     * @param  object|string  $event
      * @return void
      */
     protected function event($event)
     {
-        if (isset($this->events)) {
-            $this->events->dispatch($event);
-        }
+        $this->events?->dispatch($event);
+    }
+
+    /**
+     * Get the event dispatcher instance.
+     *
+     * @return \Illuminate\Contracts\Events\Dispatcher
+     */
+    public function getEventDispatcher()
+    {
+        return $this->events;
     }
 
     /**
@@ -435,7 +613,7 @@ class Repository implements CacheContract, ArrayAccess
      * @param  string  $key
      * @return bool
      */
-    public function offsetExists($key)
+    public function offsetExists($key): bool
     {
         return $this->has($key);
     }
@@ -446,7 +624,7 @@ class Repository implements CacheContract, ArrayAccess
      * @param  string  $key
      * @return mixed
      */
-    public function offsetGet($key)
+    public function offsetGet($key): mixed
     {
         return $this->get($key);
     }
@@ -455,10 +633,10 @@ class Repository implements CacheContract, ArrayAccess
      * Store an item in the cache for the default time.
      *
      * @param  string  $key
-     * @param  mixed   $value
+     * @param  mixed  $value
      * @return void
      */
-    public function offsetSet($key, $value)
+    public function offsetSet($key, $value): void
     {
         $this->put($key, $value, $this->default);
     }
@@ -469,31 +647,16 @@ class Repository implements CacheContract, ArrayAccess
      * @param  string  $key
      * @return void
      */
-    public function offsetUnset($key)
+    public function offsetUnset($key): void
     {
         $this->forget($key);
     }
 
-    /**
-     * Calculate the number of minutes with the given duration.
-     *
-     * @param  \DateTime|float|int  $duration
-     * @return float|int|null
-     */
-    protected function getMinutes($duration)
-    {
-        if ($duration instanceof DateTime) {
-            $duration = Carbon::now()->diffInSeconds(Carbon::instance($duration), false) / 60;
-        }
-
-        return (int) ($duration * 60) > 0 ? $duration : null;
-    }
-
     /**
      * Handle dynamic calls into macros or pass missing methods to the store.
      *
      * @param  string  $method
-     * @param  array   $parameters
+     * @param  array  $parameters
      * @return mixed
      */
     public function __call($method, $parameters)

vendor/laravel/framework/src/Illuminate/Cache/RetrievesMultipleKeys.php

@@ -16,24 +16,34 @@ trait RetrievesMultipleKeys
     {
         $return = [];
 
-        foreach ($keys as $key) {
-            $return[$key] = $this->get($key);
+        $keys = collect($keys)->mapWithKeys(function ($value, $key) {
+            return [is_string($key) ? $key : $value => is_string($key) ? $value : null];
+        })->all();
+
+        foreach ($keys as $key => $default) {
+            $return[$key] = $this->get($key, $default);
         }
 
         return $return;
     }
 
     /**
-     * Store multiple items in the cache for a given number of minutes.
+     * Store multiple items in the cache for a given number of seconds.
      *
      * @param  array  $values
-     * @param  float|int  $minutes
-     * @return void
+     * @param  int  $seconds
+     * @return bool
      */
-    public function putMany(array $values, $minutes)
+    public function putMany(array $values, $seconds)
     {
+        $manyResult = null;
+
         foreach ($values as $key => $value) {
-            $this->put($key, $value, $minutes);
+            $result = $this->put($key, $value, $seconds);
+
+            $manyResult = is_null($manyResult) ? $result : $result && $manyResult;
         }
+
+        return $manyResult ?: false;
     }
 }

vendor/laravel/framework/src/Illuminate/Cache/TagSet.php

@@ -56,6 +56,26 @@ class TagSet
         return $id;
     }
 
+    /**
+     * Flush all the tags in the set.
+     *
+     * @return void
+     */
+    public function flush()
+    {
+        array_walk($this->names, [$this, 'flushTag']);
+    }
+
+    /**
+     * Flush the tag from the cache.
+     *
+     * @param  string  $name
+     */
+    public function flushTag($name)
+    {
+        $this->store->forget($this->tagKey($name));
+    }
+
     /**
      * Get a unique namespace that changes when any of the tags are flushed.
      *

vendor/laravel/framework/src/Illuminate/Cache/TaggableStore.php

@@ -2,7 +2,9 @@
 
 namespace Illuminate\Cache;
 
-abstract class TaggableStore
+use Illuminate\Contracts\Cache\Store;
+
+abstract class TaggableStore implements Store
 {
     /**
      * Begin executing a new tags operation.

vendor/laravel/framework/src/Illuminate/Cache/TaggedCache.php

@@ -6,7 +6,9 @@ use Illuminate\Contracts\Cache\Store;
 
 class TaggedCache extends Repository
 {
-    use RetrievesMultipleKeys;
+    use RetrievesMultipleKeys {
+        putMany as putManyAlias;
+    }
 
     /**
      * The tag set instance.
@@ -30,37 +32,55 @@ class TaggedCache extends Repository
     }
 
     /**
-     * Increment the value of an item in the cache.
+     * Store multiple items in the cache for a given number of seconds.
      *
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  array  $values
+     * @param  int|null  $ttl
+     * @return bool
      */
-    public function increment($key, $value = 1)
+    public function putMany(array $values, $ttl = null)
     {
-        $this->store->increment($this->itemKey($key), $value);
+        if ($ttl === null) {
+            return $this->putManyForever($values);
+        }
+
+        return $this->putManyAlias($values, $ttl);
     }
 
     /**
      * Increment the value of an item in the cache.
      *
      * @param  string  $key
-     * @param  mixed   $value
-     * @return void
+     * @param  mixed  $value
+     * @return int|bool
+     */
+    public function increment($key, $value = 1)
+    {
+        return $this->store->increment($this->itemKey($key), $value);
+    }
+
+    /**
+     * Decrement the value of an item in the cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return int|bool
      */
     public function decrement($key, $value = 1)
     {
-        $this->store->decrement($this->itemKey($key), $value);
+        return $this->store->decrement($this->itemKey($key), $value);
     }
 
     /**
      * Remove all items from the cache.
      *
-     * @return void
+     * @return bool
      */
     public function flush()
     {
         $this->tags->reset();
+
+        return true;
     }
 
     /**
@@ -85,11 +105,21 @@ class TaggedCache extends Repository
     /**
      * Fire an event for this cache instance.
      *
-     * @param  string  $event
+     * @param  \Illuminate\Cache\Events\CacheEvent  $event
      * @return void
      */
     protected function event($event)
     {
         parent::event($event->setTags($this->tags->getNames()));
     }
+
+    /**
+     * Get the tag set instance.
+     *
+     * @return \Illuminate\Cache\TagSet
+     */
+    public function getTags()
+    {
+        return $this->tags;
+    }
 }

vendor/laravel/framework/src/Illuminate/Cache/composer.json

@@ -14,10 +14,14 @@
         }
     ],
     "require": {
-        "php": ">=5.6.4",
-        "illuminate/contracts": "5.4.*",
-        "illuminate/support": "5.4.*",
-        "nesbot/carbon": "~1.20"
+        "php": "^8.0.2",
+        "illuminate/collections": "^9.0",
+        "illuminate/contracts": "^9.0",
+        "illuminate/macroable": "^9.0",
+        "illuminate/support": "^9.0"
+    },
+    "provide": {
+        "psr/simple-cache-implementation": "1.0|2.0|3.0"
     },
     "autoload": {
         "psr-4": {
@@ -26,13 +30,15 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "5.4-dev"
+            "dev-master": "9.x-dev"
         }
     },
     "suggest": {
-        "illuminate/database": "Required to use the database cache driver (5.4.*).",
-        "illuminate/filesystem": "Required to use the file cache driver (5.4.*).",
-        "illuminate/redis": "Required to use the redis cache driver (5.4.*)."
+        "ext-memcached": "Required to use the memcache cache driver.",
+        "illuminate/database": "Required to use the database cache driver (^9.0).",
+        "illuminate/filesystem": "Required to use the file cache driver (^9.0).",
+        "illuminate/redis": "Required to use the redis cache driver (^9.0).",
+        "symfony/cache": "Required to use PSR-6 cache bridge (^6.0)."
     },
     "config": {
         "sort-packages": true