Primo Committ

vendor/laravel/framework/src/Illuminate/Redis/Connections/Connection.php

@@ -0,0 +1,222 @@
+<?php
+
+namespace Illuminate\Redis\Connections;
+
+use Closure;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Redis\Events\CommandExecuted;
+use Illuminate\Redis\Limiters\ConcurrencyLimiterBuilder;
+use Illuminate\Redis\Limiters\DurationLimiterBuilder;
+use Illuminate\Support\Traits\Macroable;
+
+abstract class Connection
+{
+    use Macroable {
+        __call as macroCall;
+    }
+
+    /**
+     * The Redis client.
+     *
+     * @var \Redis
+     */
+    protected $client;
+
+    /**
+     * The Redis connection name.
+     *
+     * @var string|null
+     */
+    protected $name;
+
+    /**
+     * The event dispatcher instance.
+     *
+     * @var \Illuminate\Contracts\Events\Dispatcher
+     */
+    protected $events;
+
+    /**
+     * Subscribe to a set of given channels for messages.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @param  string  $method
+     * @return void
+     */
+    abstract public function createSubscription($channels, Closure $callback, $method = 'subscribe');
+
+    /**
+     * Funnel a callback for a maximum number of simultaneous executions.
+     *
+     * @param  string  $name
+     * @return \Illuminate\Redis\Limiters\ConcurrencyLimiterBuilder
+     */
+    public function funnel($name)
+    {
+        return new ConcurrencyLimiterBuilder($this, $name);
+    }
+
+    /**
+     * Throttle a callback for a maximum number of executions over a given duration.
+     *
+     * @param  string  $name
+     * @return \Illuminate\Redis\Limiters\DurationLimiterBuilder
+     */
+    public function throttle($name)
+    {
+        return new DurationLimiterBuilder($this, $name);
+    }
+
+    /**
+     * Get the underlying Redis client.
+     *
+     * @return mixed
+     */
+    public function client()
+    {
+        return $this->client;
+    }
+
+    /**
+     * Subscribe to a set of given channels for messages.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function subscribe($channels, Closure $callback)
+    {
+        return $this->createSubscription($channels, $callback, __FUNCTION__);
+    }
+
+    /**
+     * Subscribe to a set of given channels with wildcards.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function psubscribe($channels, Closure $callback)
+    {
+        return $this->createSubscription($channels, $callback, __FUNCTION__);
+    }
+
+    /**
+     * Run a command against the Redis database.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function command($method, array $parameters = [])
+    {
+        $start = microtime(true);
+
+        $result = $this->client->{$method}(...$parameters);
+
+        $time = round((microtime(true) - $start) * 1000, 2);
+
+        if (isset($this->events)) {
+            $this->event(new CommandExecuted($method, $parameters, $time, $this));
+        }
+
+        return $result;
+    }
+
+    /**
+     * Fire the given event if possible.
+     *
+     * @param  mixed  $event
+     * @return void
+     */
+    protected function event($event)
+    {
+        if (isset($this->events)) {
+            $this->events->dispatch($event);
+        }
+    }
+
+    /**
+     * Register a Redis command listener with the connection.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function listen(Closure $callback)
+    {
+        if (isset($this->events)) {
+            $this->events->listen(CommandExecuted::class, $callback);
+        }
+    }
+
+    /**
+     * Get the connection name.
+     *
+     * @return string|null
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Set the connections name.
+     *
+     * @param  string  $name
+     * @return $this
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * Get the event dispatcher used by the connection.
+     *
+     * @return \Illuminate\Contracts\Events\Dispatcher
+     */
+    public function getEventDispatcher()
+    {
+        return $this->events;
+    }
+
+    /**
+     * Set the event dispatcher instance on the connection.
+     *
+     * @param  \Illuminate\Contracts\Events\Dispatcher  $events
+     * @return void
+     */
+    public function setEventDispatcher(Dispatcher $events)
+    {
+        $this->events = $events;
+    }
+
+    /**
+     * Unset the event dispatcher instance on the connection.
+     *
+     * @return void
+     */
+    public function unsetEventDispatcher()
+    {
+        $this->events = null;
+    }
+
+    /**
+     * Pass other method calls down to the underlying client.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        if (static::hasMacro($method)) {
+            return $this->macroCall($method, $parameters);
+        }
+
+        return $this->command($method, $parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Connections/PhpRedisClusterConnection.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Illuminate\Redis\Connections;
+
+class PhpRedisClusterConnection extends PhpRedisConnection
+{
+    //
+}

vendor/laravel/framework/src/Illuminate/Redis/Connections/PhpRedisConnection.php

@@ -0,0 +1,582 @@
+<?php
+
+namespace Illuminate\Redis\Connections;
+
+use Closure;
+use Illuminate\Contracts\Redis\Connection as ConnectionContract;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
+use Redis;
+use RedisCluster;
+use RedisException;
+
+/**
+ * @mixin \Redis
+ */
+class PhpRedisConnection extends Connection implements ConnectionContract
+{
+    /**
+     * The connection creation callback.
+     *
+     * @var callable
+     */
+    protected $connector;
+
+    /**
+     * The connection configuration array.
+     *
+     * @var array
+     */
+    protected $config;
+
+    /**
+     * Create a new PhpRedis connection.
+     *
+     * @param  \Redis  $client
+     * @param  callable|null  $connector
+     * @param  array  $config
+     * @return void
+     */
+    public function __construct($client, callable $connector = null, array $config = [])
+    {
+        $this->client = $client;
+        $this->config = $config;
+        $this->connector = $connector;
+    }
+
+    /**
+     * Returns the value of the given key.
+     *
+     * @param  string  $key
+     * @return string|null
+     */
+    public function get($key)
+    {
+        $result = $this->command('get', [$key]);
+
+        return $result !== false ? $result : null;
+    }
+
+    /**
+     * Get the values of all the given keys.
+     *
+     * @param  array  $keys
+     * @return array
+     */
+    public function mget(array $keys)
+    {
+        return array_map(function ($value) {
+            return $value !== false ? $value : null;
+        }, $this->command('mget', [$keys]));
+    }
+
+    /**
+     * Set the string value in argument as value of the key.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  string|null  $expireResolution
+     * @param  int|null  $expireTTL
+     * @param  string|null  $flag
+     * @return bool
+     */
+    public function set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
+    {
+        return $this->command('set', [
+            $key,
+            $value,
+            $expireResolution ? [$flag, $expireResolution => $expireTTL] : null,
+        ]);
+    }
+
+    /**
+     * Set the given key if it doesn't exist.
+     *
+     * @param  string  $key
+     * @param  string  $value
+     * @return int
+     */
+    public function setnx($key, $value)
+    {
+        return (int) $this->command('setnx', [$key, $value]);
+    }
+
+    /**
+     * Get the value of the given hash fields.
+     *
+     * @param  string  $key
+     * @param  mixed  $dictionary
+     * @return array
+     */
+    public function hmget($key, ...$dictionary)
+    {
+        if (count($dictionary) === 1) {
+            $dictionary = $dictionary[0];
+        }
+
+        return array_values($this->command('hmget', [$key, $dictionary]));
+    }
+
+    /**
+     * Set the given hash fields to their respective values.
+     *
+     * @param  string  $key
+     * @param  mixed  $dictionary
+     * @return int
+     */
+    public function hmset($key, ...$dictionary)
+    {
+        if (count($dictionary) === 1) {
+            $dictionary = $dictionary[0];
+        } else {
+            $input = collect($dictionary);
+
+            $dictionary = $input->nth(2)->combine($input->nth(2, 1))->toArray();
+        }
+
+        return $this->command('hmset', [$key, $dictionary]);
+    }
+
+    /**
+     * Set the given hash field if it doesn't exist.
+     *
+     * @param  string  $hash
+     * @param  string  $key
+     * @param  string  $value
+     * @return int
+     */
+    public function hsetnx($hash, $key, $value)
+    {
+        return (int) $this->command('hsetnx', [$hash, $key, $value]);
+    }
+
+    /**
+     * Removes the first count occurrences of the value element from the list.
+     *
+     * @param  string  $key
+     * @param  int  $count
+     * @param  mixed  $value
+     * @return int|false
+     */
+    public function lrem($key, $count, $value)
+    {
+        return $this->command('lrem', [$key, $value, $count]);
+    }
+
+    /**
+     * Removes and returns the first element of the list stored at key.
+     *
+     * @param  mixed  $arguments
+     * @return array|null
+     */
+    public function blpop(...$arguments)
+    {
+        $result = $this->command('blpop', $arguments);
+
+        return empty($result) ? null : $result;
+    }
+
+    /**
+     * Removes and returns the last element of the list stored at key.
+     *
+     * @param  mixed  $arguments
+     * @return array|null
+     */
+    public function brpop(...$arguments)
+    {
+        $result = $this->command('brpop', $arguments);
+
+        return empty($result) ? null : $result;
+    }
+
+    /**
+     * Removes and returns a random element from the set value at key.
+     *
+     * @param  string  $key
+     * @param  int|null  $count
+     * @return mixed|false
+     */
+    public function spop($key, $count = 1)
+    {
+        return $this->command('spop', func_get_args());
+    }
+
+    /**
+     * Add one or more members to a sorted set or update its score if it already exists.
+     *
+     * @param  string  $key
+     * @param  mixed  $dictionary
+     * @return int
+     */
+    public function zadd($key, ...$dictionary)
+    {
+        if (is_array(end($dictionary))) {
+            foreach (array_pop($dictionary) as $member => $score) {
+                $dictionary[] = $score;
+                $dictionary[] = $member;
+            }
+        }
+
+        $options = [];
+
+        foreach (array_slice($dictionary, 0, 3) as $i => $value) {
+            if (in_array($value, ['nx', 'xx', 'ch', 'incr', 'NX', 'XX', 'CH', 'INCR'], true)) {
+                $options[] = $value;
+
+                unset($dictionary[$i]);
+            }
+        }
+
+        return $this->command('zadd', array_merge([$key], [$options], array_values($dictionary)));
+    }
+
+    /**
+     * Return elements with score between $min and $max.
+     *
+     * @param  string  $key
+     * @param  mixed  $min
+     * @param  mixed  $max
+     * @param  array  $options
+     * @return array
+     */
+    public function zrangebyscore($key, $min, $max, $options = [])
+    {
+        if (isset($options['limit']) && Arr::isAssoc($options['limit'])) {
+            $options['limit'] = [
+                $options['limit']['offset'],
+                $options['limit']['count'],
+            ];
+        }
+
+        return $this->command('zRangeByScore', [$key, $min, $max, $options]);
+    }
+
+    /**
+     * Return elements with score between $min and $max.
+     *
+     * @param  string  $key
+     * @param  mixed  $min
+     * @param  mixed  $max
+     * @param  array  $options
+     * @return array
+     */
+    public function zrevrangebyscore($key, $min, $max, $options = [])
+    {
+        if (isset($options['limit']) && Arr::isAssoc($options['limit'])) {
+            $options['limit'] = [
+                $options['limit']['offset'],
+                $options['limit']['count'],
+            ];
+        }
+
+        return $this->command('zRevRangeByScore', [$key, $min, $max, $options]);
+    }
+
+    /**
+     * Find the intersection between sets and store in a new set.
+     *
+     * @param  string  $output
+     * @param  array  $keys
+     * @param  array  $options
+     * @return int
+     */
+    public function zinterstore($output, $keys, $options = [])
+    {
+        return $this->command('zinterstore', [$output, $keys,
+            $options['weights'] ?? null,
+            $options['aggregate'] ?? 'sum',
+        ]);
+    }
+
+    /**
+     * Find the union between sets and store in a new set.
+     *
+     * @param  string  $output
+     * @param  array  $keys
+     * @param  array  $options
+     * @return int
+     */
+    public function zunionstore($output, $keys, $options = [])
+    {
+        return $this->command('zunionstore', [$output, $keys,
+            $options['weights'] ?? null,
+            $options['aggregate'] ?? 'sum',
+        ]);
+    }
+
+    /**
+     * Scans all keys based on options.
+     *
+     * @param  mixed  $cursor
+     * @param  array  $options
+     * @return mixed
+     */
+    public function scan($cursor, $options = [])
+    {
+        $result = $this->client->scan($cursor,
+            $options['match'] ?? '*',
+            $options['count'] ?? 10
+        );
+
+        if ($result === false) {
+            $result = [];
+        }
+
+        return $cursor === 0 && empty($result) ? false : [$cursor, $result];
+    }
+
+    /**
+     * Scans the given set for all values based on options.
+     *
+     * @param  string  $key
+     * @param  mixed  $cursor
+     * @param  array  $options
+     * @return mixed
+     */
+    public function zscan($key, $cursor, $options = [])
+    {
+        $result = $this->client->zscan($key, $cursor,
+            $options['match'] ?? '*',
+            $options['count'] ?? 10
+        );
+
+        if ($result === false) {
+            $result = [];
+        }
+
+        return $cursor === 0 && empty($result) ? false : [$cursor, $result];
+    }
+
+    /**
+     * Scans the given hash for all values based on options.
+     *
+     * @param  string  $key
+     * @param  mixed  $cursor
+     * @param  array  $options
+     * @return mixed
+     */
+    public function hscan($key, $cursor, $options = [])
+    {
+        $result = $this->client->hscan($key, $cursor,
+            $options['match'] ?? '*',
+            $options['count'] ?? 10
+        );
+
+        if ($result === false) {
+            $result = [];
+        }
+
+        return $cursor === 0 && empty($result) ? false : [$cursor, $result];
+    }
+
+    /**
+     * Scans the given set for all values based on options.
+     *
+     * @param  string  $key
+     * @param  mixed  $cursor
+     * @param  array  $options
+     * @return mixed
+     */
+    public function sscan($key, $cursor, $options = [])
+    {
+        $result = $this->client->sscan($key, $cursor,
+            $options['match'] ?? '*',
+            $options['count'] ?? 10
+        );
+
+        if ($result === false) {
+            $result = [];
+        }
+
+        return $cursor === 0 && empty($result) ? false : [$cursor, $result];
+    }
+
+    /**
+     * Execute commands in a pipeline.
+     *
+     * @param  callable|null  $callback
+     * @return \Redis|array
+     */
+    public function pipeline(callable $callback = null)
+    {
+        $pipeline = $this->client()->pipeline();
+
+        return is_null($callback)
+            ? $pipeline
+            : tap($pipeline, $callback)->exec();
+    }
+
+    /**
+     * Execute commands in a transaction.
+     *
+     * @param  callable|null  $callback
+     * @return \Redis|array
+     */
+    public function transaction(callable $callback = null)
+    {
+        $transaction = $this->client()->multi();
+
+        return is_null($callback)
+            ? $transaction
+            : tap($transaction, $callback)->exec();
+    }
+
+    /**
+     * Evaluate a LUA script serverside, from the SHA1 hash of the script instead of the script itself.
+     *
+     * @param  string  $script
+     * @param  int  $numkeys
+     * @param  mixed  $arguments
+     * @return mixed
+     */
+    public function evalsha($script, $numkeys, ...$arguments)
+    {
+        return $this->command('evalsha', [
+            $this->script('load', $script), $arguments, $numkeys,
+        ]);
+    }
+
+    /**
+     * Evaluate a script and return its result.
+     *
+     * @param  string  $script
+     * @param  int  $numberOfKeys
+     * @param  dynamic  $arguments
+     * @return mixed
+     */
+    public function eval($script, $numberOfKeys, ...$arguments)
+    {
+        return $this->command('eval', [$script, $arguments, $numberOfKeys]);
+    }
+
+    /**
+     * Subscribe to a set of given channels for messages.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function subscribe($channels, Closure $callback)
+    {
+        $this->client->subscribe((array) $channels, function ($redis, $channel, $message) use ($callback) {
+            $callback($message, $channel);
+        });
+    }
+
+    /**
+     * Subscribe to a set of given channels with wildcards.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function psubscribe($channels, Closure $callback)
+    {
+        $this->client->psubscribe((array) $channels, function ($redis, $pattern, $channel, $message) use ($callback) {
+            $callback($message, $channel);
+        });
+    }
+
+    /**
+     * Subscribe to a set of given channels for messages.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @param  string  $method
+     * @return void
+     */
+    public function createSubscription($channels, Closure $callback, $method = 'subscribe')
+    {
+        //
+    }
+
+    /**
+     * Flush the selected Redis database.
+     *
+     * @return void
+     */
+    public function flushdb()
+    {
+        if (! $this->client instanceof RedisCluster) {
+            return $this->command('flushdb');
+        }
+
+        foreach ($this->client->_masters() as [$host, $port]) {
+            $redis = tap(new Redis)->connect($host, $port);
+
+            if (isset($this->config['password']) && ! empty($this->config['password'])) {
+                $redis->auth($this->config['password']);
+            }
+
+            $redis->flushDb();
+        }
+    }
+
+    /**
+     * Execute a raw command.
+     *
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function executeRaw(array $parameters)
+    {
+        return $this->command('rawCommand', $parameters);
+    }
+
+    /**
+     * Run a command against the Redis database.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \RedisException
+     */
+    public function command($method, array $parameters = [])
+    {
+        try {
+            return parent::command($method, $parameters);
+        } catch (RedisException $e) {
+            if (Str::contains($e->getMessage(), 'went away')) {
+                $this->client = $this->connector ? call_user_func($this->connector) : $this->client;
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Disconnects from the Redis instance.
+     *
+     * @return void
+     */
+    public function disconnect()
+    {
+        $this->client->close();
+    }
+
+    /**
+     * Apply prefix to the given key if necessary.
+     *
+     * @param  string  $key
+     * @return string
+     */
+    private function applyPrefix($key)
+    {
+        $prefix = (string) $this->client->getOption(Redis::OPT_PREFIX);
+
+        return $prefix.$key;
+    }
+
+    /**
+     * Pass other method calls down to the underlying client.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return parent::__call(strtolower($method), $parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Connections/PredisClusterConnection.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Illuminate\Redis\Connections;
+
+class PredisClusterConnection extends PredisConnection
+{
+    //
+}

vendor/laravel/framework/src/Illuminate/Redis/Connections/PredisConnection.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Illuminate\Redis\Connections;
+
+use Closure;
+use Illuminate\Contracts\Redis\Connection as ConnectionContract;
+use Predis\Command\ServerFlushDatabase;
+use Predis\Connection\Aggregate\ClusterInterface;
+
+/**
+ * @mixin \Predis\Client
+ */
+class PredisConnection extends Connection implements ConnectionContract
+{
+    /**
+     * The Predis client.
+     *
+     * @var \Predis\Client
+     */
+    protected $client;
+
+    /**
+     * Create a new Predis connection.
+     *
+     * @param  \Predis\Client  $client
+     * @return void
+     */
+    public function __construct($client)
+    {
+        $this->client = $client;
+    }
+
+    /**
+     * Subscribe to a set of given channels for messages.
+     *
+     * @param  array|string  $channels
+     * @param  \Closure  $callback
+     * @param  string  $method
+     * @return void
+     */
+    public function createSubscription($channels, Closure $callback, $method = 'subscribe')
+    {
+        $loop = $this->pubSubLoop();
+
+        $loop->{$method}(...array_values((array) $channels));
+
+        foreach ($loop as $message) {
+            if ($message->kind === 'message' || $message->kind === 'pmessage') {
+                call_user_func($callback, $message->payload, $message->channel);
+            }
+        }
+
+        unset($loop);
+    }
+
+    /**
+     * Flush the selected Redis database.
+     *
+     * @return void
+     */
+    public function flushdb()
+    {
+        if (! $this->client->getConnection() instanceof ClusterInterface) {
+            return $this->command('flushdb');
+        }
+
+        foreach ($this->getConnection() as $node) {
+            $node->executeCommand(new ServerFlushDatabase);
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Connectors/PhpRedisConnector.php

@@ -0,0 +1,196 @@
+<?php
+
+namespace Illuminate\Redis\Connectors;
+
+use Illuminate\Contracts\Redis\Connector;
+use Illuminate\Redis\Connections\PhpRedisClusterConnection;
+use Illuminate\Redis\Connections\PhpRedisConnection;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\Redis as RedisFacade;
+use Illuminate\Support\Str;
+use LogicException;
+use Redis;
+use RedisCluster;
+
+class PhpRedisConnector implements Connector
+{
+    /**
+     * Create a new clustered PhpRedis connection.
+     *
+     * @param  array  $config
+     * @param  array  $options
+     * @return \Illuminate\Redis\Connections\PhpRedisConnection
+     */
+    public function connect(array $config, array $options)
+    {
+        $connector = function () use ($config, $options) {
+            return $this->createClient(array_merge(
+                $config, $options, Arr::pull($config, 'options', [])
+            ));
+        };
+
+        return new PhpRedisConnection($connector(), $connector, $config);
+    }
+
+    /**
+     * Create a new clustered PhpRedis connection.
+     *
+     * @param  array  $config
+     * @param  array  $clusterOptions
+     * @param  array  $options
+     * @return \Illuminate\Redis\Connections\PhpRedisClusterConnection
+     */
+    public function connectToCluster(array $config, array $clusterOptions, array $options)
+    {
+        $options = array_merge($options, $clusterOptions, Arr::pull($config, 'options', []));
+
+        return new PhpRedisClusterConnection($this->createRedisClusterInstance(
+            array_map([$this, 'buildClusterConnectionString'], $config), $options
+        ));
+    }
+
+    /**
+     * Build a single cluster seed string from array.
+     *
+     * @param  array  $server
+     * @return string
+     */
+    protected function buildClusterConnectionString(array $server)
+    {
+        return $this->formatHost($server).':'.$server['port'].'?'.Arr::query(Arr::only($server, [
+            'database', 'password', 'prefix', 'read_timeout',
+        ]));
+    }
+
+    /**
+     * Create the Redis client instance.
+     *
+     * @param  array  $config
+     * @return \Redis
+     *
+     * @throws \LogicException
+     */
+    protected function createClient(array $config)
+    {
+        return tap(new Redis, function ($client) use ($config) {
+            if ($client instanceof RedisFacade) {
+                throw new LogicException(
+                    extension_loaded('redis')
+                        ? 'Please remove or rename the Redis facade alias in your "app" configuration file in order to avoid collision with the PHP Redis extension.'
+                        : 'Please make sure the PHP Redis extension is installed and enabled.'
+                );
+            }
+
+            $this->establishConnection($client, $config);
+
+            if (! empty($config['password'])) {
+                $client->auth($config['password']);
+            }
+
+            if (isset($config['database'])) {
+                $client->select((int) $config['database']);
+            }
+
+            if (! empty($config['prefix'])) {
+                $client->setOption(Redis::OPT_PREFIX, $config['prefix']);
+            }
+
+            if (! empty($config['read_timeout'])) {
+                $client->setOption(Redis::OPT_READ_TIMEOUT, $config['read_timeout']);
+            }
+
+            if (! empty($config['scan'])) {
+                $client->setOption(Redis::OPT_SCAN, $config['scan']);
+            }
+        });
+    }
+
+    /**
+     * Establish a connection with the Redis host.
+     *
+     * @param  \Redis  $client
+     * @param  array  $config
+     * @return void
+     */
+    protected function establishConnection($client, array $config)
+    {
+        $persistent = $config['persistent'] ?? false;
+
+        $parameters = [
+            $this->formatHost($config),
+            $config['port'],
+            Arr::get($config, 'timeout', 0.0),
+            $persistent ? Arr::get($config, 'persistent_id', null) : null,
+            Arr::get($config, 'retry_interval', 0),
+        ];
+
+        if (version_compare(phpversion('redis'), '3.1.3', '>=')) {
+            $parameters[] = Arr::get($config, 'read_timeout', 0.0);
+        }
+
+        if (version_compare(phpversion('redis'), '5.3.0', '>=')) {
+            if (! is_null($context = Arr::get($config, 'context'))) {
+                $parameters[] = $context;
+            }
+        }
+
+        $client->{($persistent ? 'pconnect' : 'connect')}(...$parameters);
+    }
+
+    /**
+     * Create a new redis cluster instance.
+     *
+     * @param  array  $servers
+     * @param  array  $options
+     * @return \RedisCluster
+     */
+    protected function createRedisClusterInstance(array $servers, array $options)
+    {
+        $parameters = [
+            null,
+            array_values($servers),
+            $options['timeout'] ?? 0,
+            $options['read_timeout'] ?? 0,
+            isset($options['persistent']) && $options['persistent'],
+        ];
+
+        if (version_compare(phpversion('redis'), '4.3.0', '>=')) {
+            $parameters[] = $options['password'] ?? null;
+        }
+
+        if (version_compare(phpversion('redis'), '5.3.2', '>=')) {
+            if (! is_null($context = Arr::get($options, 'context'))) {
+                $parameters[] = $context;
+            }
+        }
+
+        return tap(new RedisCluster(...$parameters), function ($client) use ($options) {
+            if (! empty($options['prefix'])) {
+                $client->setOption(RedisCluster::OPT_PREFIX, $options['prefix']);
+            }
+
+            if (! empty($options['scan'])) {
+                $client->setOption(RedisCluster::OPT_SCAN, $options['scan']);
+            }
+
+            if (! empty($options['failover'])) {
+                $client->setOption(RedisCluster::OPT_SLAVE_FAILOVER, $options['failover']);
+            }
+        });
+    }
+
+    /**
+     * Format the host using the scheme if available.
+     *
+     * @param  array  $options
+     * @return string
+     */
+    protected function formatHost(array $options)
+    {
+        if (isset($options['scheme'])) {
+            return Str::start($options['host'], "{$options['scheme']}://");
+        }
+
+        return $options['host'];
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Connectors/PredisConnector.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Illuminate\Redis\Connectors;
+
+use Illuminate\Contracts\Redis\Connector;
+use Illuminate\Redis\Connections\PredisClusterConnection;
+use Illuminate\Redis\Connections\PredisConnection;
+use Illuminate\Support\Arr;
+use Predis\Client;
+
+class PredisConnector implements Connector
+{
+    /**
+     * Create a new clustered Predis connection.
+     *
+     * @param  array  $config
+     * @param  array  $options
+     * @return \Illuminate\Redis\Connections\PredisConnection
+     */
+    public function connect(array $config, array $options)
+    {
+        $formattedOptions = array_merge(
+            ['timeout' => 10.0], $options, Arr::pull($config, 'options', [])
+        );
+
+        return new PredisConnection(new Client($config, $formattedOptions));
+    }
+
+    /**
+     * Create a new clustered Predis connection.
+     *
+     * @param  array  $config
+     * @param  array  $clusterOptions
+     * @param  array  $options
+     * @return \Illuminate\Redis\Connections\PredisClusterConnection
+     */
+    public function connectToCluster(array $config, array $clusterOptions, array $options)
+    {
+        $clusterSpecificOptions = Arr::pull($config, 'options', []);
+
+        return new PredisClusterConnection(new Client(array_values($config), array_merge(
+            $options, $clusterOptions, $clusterSpecificOptions
+        )));
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Events/CommandExecuted.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Illuminate\Redis\Events;
+
+class CommandExecuted
+{
+    /**
+     * The Redis command that was executed.
+     *
+     * @var string
+     */
+    public $command;
+
+    /**
+     * The array of command parameters.
+     *
+     * @var array
+     */
+    public $parameters;
+
+    /**
+     * The number of milliseconds it took to execute the command.
+     *
+     * @var float
+     */
+    public $time;
+
+    /**
+     * The Redis connection instance.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    public $connection;
+
+    /**
+     * The Redis connection name.
+     *
+     * @var string
+     */
+    public $connectionName;
+
+    /**
+     * Create a new event instance.
+     *
+     * @param  string  $command
+     * @param  array  $parameters
+     * @param  float|null  $time
+     * @param  \Illuminate\Redis\Connections\Connection  $connection
+     * @return void
+     */
+    public function __construct($command, $parameters, $time, $connection)
+    {
+        $this->time = $time;
+        $this->command = $command;
+        $this->parameters = $parameters;
+        $this->connection = $connection;
+        $this->connectionName = $connection->getName();
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/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/Redis/Limiters/ConcurrencyLimiter.php

@@ -0,0 +1,166 @@
+<?php
+
+namespace Illuminate\Redis\Limiters;
+
+use Exception;
+use Illuminate\Contracts\Redis\LimiterTimeoutException;
+use Illuminate\Support\Str;
+
+class ConcurrencyLimiter
+{
+    /**
+     * The Redis factory implementation.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    protected $redis;
+
+    /**
+     * The name of the limiter.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The allowed number of concurrent tasks.
+     *
+     * @var int
+     */
+    protected $maxLocks;
+
+    /**
+     * The number of seconds a slot should be maintained.
+     *
+     * @var int
+     */
+    protected $releaseAfter;
+
+    /**
+     * Create a new concurrency limiter instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $redis
+     * @param  string  $name
+     * @param  int  $maxLocks
+     * @param  int  $releaseAfter
+     * @return void
+     */
+    public function __construct($redis, $name, $maxLocks, $releaseAfter)
+    {
+        $this->name = $name;
+        $this->redis = $redis;
+        $this->maxLocks = $maxLocks;
+        $this->releaseAfter = $releaseAfter;
+    }
+
+    /**
+     * Attempt to acquire the lock for the given number of seconds.
+     *
+     * @param  int  $timeout
+     * @param  callable|null  $callback
+     * @return bool
+     *
+     * @throws \Illuminate\Contracts\Redis\LimiterTimeoutException
+     * @throws \Exception
+     */
+    public function block($timeout, $callback = null)
+    {
+        $starting = time();
+
+        $id = Str::random(20);
+
+        while (! $slot = $this->acquire($id)) {
+            if (time() - $timeout >= $starting) {
+                throw new LimiterTimeoutException;
+            }
+
+            usleep(250 * 1000);
+        }
+
+        if (is_callable($callback)) {
+            try {
+                return tap($callback(), function () use ($slot, $id) {
+                    $this->release($slot, $id);
+                });
+            } catch (Exception $exception) {
+                $this->release($slot, $id);
+
+                throw $exception;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @param  string  $id  A unique identifier for this lock
+     * @return mixed
+     */
+    protected function acquire($id)
+    {
+        $slots = array_map(function ($i) {
+            return $this->name.$i;
+        }, range(1, $this->maxLocks));
+
+        return $this->redis->eval(...array_merge(
+            [$this->lockScript(), count($slots)],
+            array_merge($slots, [$this->name, $this->releaseAfter, $id])
+        ));
+    }
+
+    /**
+     * Get the Lua script for acquiring a lock.
+     *
+     * KEYS    - The keys that represent available slots
+     * ARGV[1] - The limiter name
+     * ARGV[2] - The number of seconds the slot should be reserved
+     * ARGV[3] - The unique identifier for this lock
+     *
+     * @return string
+     */
+    protected function lockScript()
+    {
+        return <<<'LUA'
+for index, value in pairs(redis.call('mget', unpack(KEYS))) do
+    if not value then
+        redis.call('set', KEYS[index], ARGV[3], "EX", ARGV[2])
+        return ARGV[1]..index
+    end
+end
+LUA;
+    }
+
+    /**
+     * Release the lock.
+     *
+     * @param  string  $key
+     * @param  string  $id
+     * @return void
+     */
+    protected function release($key, $id)
+    {
+        $this->redis->eval($this->releaseScript(), 1, $key, $id);
+    }
+
+    /**
+     * Get the Lua script to atomically release a lock.
+     *
+     * KEYS[1] - The name of the lock
+     * ARGV[1] - The unique identifier for this lock
+     *
+     * @return string
+     */
+    protected function releaseScript()
+    {
+        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/Redis/Limiters/ConcurrencyLimiterBuilder.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Illuminate\Redis\Limiters;
+
+use Illuminate\Contracts\Redis\LimiterTimeoutException;
+use Illuminate\Support\InteractsWithTime;
+
+class ConcurrencyLimiterBuilder
+{
+    use InteractsWithTime;
+
+    /**
+     * The Redis connection.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    public $connection;
+
+    /**
+     * The name of the lock.
+     *
+     * @var string
+     */
+    public $name;
+
+    /**
+     * The maximum number of entities that can hold the lock at the same time.
+     *
+     * @var int
+     */
+    public $maxLocks;
+
+    /**
+     * The number of seconds to maintain the lock until it is automatically released.
+     *
+     * @var int
+     */
+    public $releaseAfter = 60;
+
+    /**
+     * The amount of time to block until a lock is available.
+     *
+     * @var int
+     */
+    public $timeout = 3;
+
+    /**
+     * Create a new builder instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $connection
+     * @param  string  $name
+     * @return void
+     */
+    public function __construct($connection, $name)
+    {
+        $this->name = $name;
+        $this->connection = $connection;
+    }
+
+    /**
+     * Set the maximum number of locks that can obtained per time window.
+     *
+     * @param  int  $maxLocks
+     * @return $this
+     */
+    public function limit($maxLocks)
+    {
+        $this->maxLocks = $maxLocks;
+
+        return $this;
+    }
+
+    /**
+     * Set the number of seconds until the lock will be released.
+     *
+     * @param  int  $releaseAfter
+     * @return $this
+     */
+    public function releaseAfter($releaseAfter)
+    {
+        $this->releaseAfter = $this->secondsUntil($releaseAfter);
+
+        return $this;
+    }
+
+    /**
+     * Set the amount of time to block until a lock is available.
+     *
+     * @param  int  $timeout
+     * @return $this
+     */
+    public function block($timeout)
+    {
+        $this->timeout = $timeout;
+
+        return $this;
+    }
+
+    /**
+     * Execute the given callback if a lock is obtained, otherwise call the failure callback.
+     *
+     * @param  callable  $callback
+     * @param  callable|null  $failure
+     * @return mixed
+     *
+     * @throws \Illuminate\Contracts\Redis\LimiterTimeoutException
+     */
+    public function then(callable $callback, callable $failure = null)
+    {
+        try {
+            return (new ConcurrencyLimiter(
+                $this->connection, $this->name, $this->maxLocks, $this->releaseAfter
+            ))->block($this->timeout, $callback);
+        } catch (LimiterTimeoutException $e) {
+            if ($failure) {
+                return $failure($e);
+            }
+
+            throw $e;
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Limiters/DurationLimiter.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Illuminate\Redis\Limiters;
+
+use Illuminate\Contracts\Redis\LimiterTimeoutException;
+
+class DurationLimiter
+{
+    /**
+     * The Redis factory implementation.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    private $redis;
+
+    /**
+     * The unique name of the lock.
+     *
+     * @var string
+     */
+    private $name;
+
+    /**
+     * The allowed number of concurrent tasks.
+     *
+     * @var int
+     */
+    private $maxLocks;
+
+    /**
+     * The number of seconds a slot should be maintained.
+     *
+     * @var int
+     */
+    private $decay;
+
+    /**
+     * The timestamp of the end of the current duration.
+     *
+     * @var int
+     */
+    public $decaysAt;
+
+    /**
+     * The number of remaining slots.
+     *
+     * @var int
+     */
+    public $remaining;
+
+    /**
+     * Create a new duration limiter instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $redis
+     * @param  string  $name
+     * @param  int  $maxLocks
+     * @param  int  $decay
+     * @return void
+     */
+    public function __construct($redis, $name, $maxLocks, $decay)
+    {
+        $this->name = $name;
+        $this->decay = $decay;
+        $this->redis = $redis;
+        $this->maxLocks = $maxLocks;
+    }
+
+    /**
+     * Attempt to acquire the lock for the given number of seconds.
+     *
+     * @param  int  $timeout
+     * @param  callable|null  $callback
+     * @return mixed
+     *
+     * @throws \Illuminate\Contracts\Redis\LimiterTimeoutException
+     */
+    public function block($timeout, $callback = null)
+    {
+        $starting = time();
+
+        while (! $this->acquire()) {
+            if (time() - $timeout >= $starting) {
+                throw new LimiterTimeoutException;
+            }
+
+            usleep(750 * 1000);
+        }
+
+        if (is_callable($callback)) {
+            return $callback();
+        }
+
+        return true;
+    }
+
+    /**
+     * Attempt to acquire the lock.
+     *
+     * @return bool
+     */
+    public function acquire()
+    {
+        $results = $this->redis->eval(
+            $this->luaScript(), 1, $this->name, microtime(true), time(), $this->decay, $this->maxLocks
+        );
+
+        $this->decaysAt = $results[1];
+
+        $this->remaining = max(0, $results[2]);
+
+        return (bool) $results[0];
+    }
+
+    /**
+     * Get the Lua script for acquiring a lock.
+     *
+     * KEYS[1] - The limiter name
+     * ARGV[1] - Current time in microseconds
+     * ARGV[2] - Current time in seconds
+     * ARGV[3] - Duration of the bucket
+     * ARGV[4] - Allowed number of tasks
+     *
+     * @return string
+     */
+    protected function luaScript()
+    {
+        return <<<'LUA'
+local function reset()
+    redis.call('HMSET', KEYS[1], 'start', ARGV[2], 'end', ARGV[2] + ARGV[3], 'count', 1)
+    return redis.call('EXPIRE', KEYS[1], ARGV[3] * 2)
+end
+
+if redis.call('EXISTS', KEYS[1]) == 0 then
+    return {reset(), ARGV[2] + ARGV[3], ARGV[4] - 1}
+end
+
+if ARGV[1] >= redis.call('HGET', KEYS[1], 'start') and ARGV[1] <= redis.call('HGET', KEYS[1], 'end') then
+    return {
+        tonumber(redis.call('HINCRBY', KEYS[1], 'count', 1)) <= tonumber(ARGV[4]),
+        redis.call('HGET', KEYS[1], 'end'),
+        ARGV[4] - redis.call('HGET', KEYS[1], 'count')
+    }
+end
+
+return {reset(), ARGV[2] + ARGV[3], ARGV[4] - 1}
+LUA;
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/Limiters/DurationLimiterBuilder.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Illuminate\Redis\Limiters;
+
+use Illuminate\Contracts\Redis\LimiterTimeoutException;
+use Illuminate\Support\InteractsWithTime;
+
+class DurationLimiterBuilder
+{
+    use InteractsWithTime;
+
+    /**
+     * The Redis connection.
+     *
+     * @var \Illuminate\Redis\Connections\Connection
+     */
+    public $connection;
+
+    /**
+     * The name of the lock.
+     *
+     * @var string
+     */
+    public $name;
+
+    /**
+     * The maximum number of locks that can obtained per time window.
+     *
+     * @var int
+     */
+    public $maxLocks;
+
+    /**
+     * The amount of time the lock window is maintained.
+     *
+     * @var int
+     */
+    public $decay;
+
+    /**
+     * The amount of time to block until a lock is available.
+     *
+     * @var int
+     */
+    public $timeout = 3;
+
+    /**
+     * Create a new builder instance.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $connection
+     * @param  string  $name
+     * @return void
+     */
+    public function __construct($connection, $name)
+    {
+        $this->name = $name;
+        $this->connection = $connection;
+    }
+
+    /**
+     * Set the maximum number of locks that can obtained per time window.
+     *
+     * @param  int  $maxLocks
+     * @return $this
+     */
+    public function allow($maxLocks)
+    {
+        $this->maxLocks = $maxLocks;
+
+        return $this;
+    }
+
+    /**
+     * Set the amount of time the lock window is maintained.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $decay
+     * @return $this
+     */
+    public function every($decay)
+    {
+        $this->decay = $this->secondsUntil($decay);
+
+        return $this;
+    }
+
+    /**
+     * Set the amount of time to block until a lock is available.
+     *
+     * @param  int  $timeout
+     * @return $this
+     */
+    public function block($timeout)
+    {
+        $this->timeout = $timeout;
+
+        return $this;
+    }
+
+    /**
+     * Execute the given callback if a lock is obtained, otherwise call the failure callback.
+     *
+     * @param  callable  $callback
+     * @param  callable|null  $failure
+     * @return mixed
+     *
+     * @throws \Illuminate\Contracts\Redis\LimiterTimeoutException
+     */
+    public function then(callable $callback, callable $failure = null)
+    {
+        try {
+            return (new DurationLimiter(
+                $this->connection, $this->name, $this->maxLocks, $this->decay
+            ))->block($this->timeout, $callback);
+        } catch (LimiterTimeoutException $e) {
+            if ($failure) {
+                return $failure($e);
+            }
+
+            throw $e;
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/RedisManager.php

@@ -0,0 +1,265 @@
+<?php
+
+namespace Illuminate\Redis;
+
+use Closure;
+use Illuminate\Contracts\Redis\Factory;
+use Illuminate\Redis\Connections\Connection;
+use Illuminate\Redis\Connectors\PhpRedisConnector;
+use Illuminate\Redis\Connectors\PredisConnector;
+use Illuminate\Support\ConfigurationUrlParser;
+use InvalidArgumentException;
+
+/**
+ * @mixin \Illuminate\Redis\Connections\Connection
+ */
+class RedisManager implements Factory
+{
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * The name of the default driver.
+     *
+     * @var string
+     */
+    protected $driver;
+
+    /**
+     * The registered custom driver creators.
+     *
+     * @var array
+     */
+    protected $customCreators = [];
+
+    /**
+     * The Redis server configurations.
+     *
+     * @var array
+     */
+    protected $config;
+
+    /**
+     * The Redis connections.
+     *
+     * @var mixed
+     */
+    protected $connections;
+
+    /**
+     * Indicates whether event dispatcher is set on connections.
+     *
+     * @var bool
+     */
+    protected $events = false;
+
+    /**
+     * Create a new Redis manager instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @param  string  $driver
+     * @param  array  $config
+     * @return void
+     */
+    public function __construct($app, $driver, array $config)
+    {
+        $this->app = $app;
+        $this->driver = $driver;
+        $this->config = $config;
+    }
+
+    /**
+     * Get a Redis connection by name.
+     *
+     * @param  string|null  $name
+     * @return \Illuminate\Redis\Connections\Connection
+     */
+    public function connection($name = null)
+    {
+        $name = $name ?: 'default';
+
+        if (isset($this->connections[$name])) {
+            return $this->connections[$name];
+        }
+
+        return $this->connections[$name] = $this->configure(
+            $this->resolve($name), $name
+        );
+    }
+
+    /**
+     * Resolve the given connection by name.
+     *
+     * @param  string|null  $name
+     * @return \Illuminate\Redis\Connections\Connection
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function resolve($name = null)
+    {
+        $name = $name ?: 'default';
+
+        $options = $this->config['options'] ?? [];
+
+        if (isset($this->config[$name])) {
+            return $this->connector()->connect(
+                $this->parseConnectionConfiguration($this->config[$name]),
+                $options
+            );
+        }
+
+        if (isset($this->config['clusters'][$name])) {
+            return $this->resolveCluster($name);
+        }
+
+        throw new InvalidArgumentException("Redis connection [{$name}] not configured.");
+    }
+
+    /**
+     * Resolve the given cluster connection by name.
+     *
+     * @param  string  $name
+     * @return \Illuminate\Redis\Connections\Connection
+     */
+    protected function resolveCluster($name)
+    {
+        return $this->connector()->connectToCluster(
+            array_map(function ($config) {
+                return $this->parseConnectionConfiguration($config);
+            }, $this->config['clusters'][$name]),
+            $this->config['clusters']['options'] ?? [],
+            $this->config['options'] ?? []
+        );
+    }
+
+    /**
+     * Configure the given connection to prepare it for commands.
+     *
+     * @param  \Illuminate\Redis\Connections\Connection  $connection
+     * @param  string  $name
+     * @return \Illuminate\Redis\Connections\Connection
+     */
+    protected function configure(Connection $connection, $name)
+    {
+        $connection->setName($name);
+
+        if ($this->events && $this->app->bound('events')) {
+            $connection->setEventDispatcher($this->app->make('events'));
+        }
+
+        return $connection;
+    }
+
+    /**
+     * Get the connector instance for the current driver.
+     *
+     * @return \Illuminate\Contracts\Redis\Connector
+     */
+    protected function connector()
+    {
+        $customCreator = $this->customCreators[$this->driver] ?? null;
+
+        if ($customCreator) {
+            return $customCreator();
+        }
+
+        switch ($this->driver) {
+            case 'predis':
+                return new PredisConnector;
+            case 'phpredis':
+                return new PhpRedisConnector;
+        }
+    }
+
+    /**
+     * Parse the Redis connection configuration.
+     *
+     * @param  mixed  $config
+     * @return array
+     */
+    protected function parseConnectionConfiguration($config)
+    {
+        $parsed = (new ConfigurationUrlParser)->parseConfiguration($config);
+
+        $driver = strtolower($parsed['driver'] ?? '');
+
+        if (in_array($driver, ['tcp', 'tls'])) {
+            $parsed['scheme'] = $driver;
+        }
+
+        return array_filter($parsed, function ($key) {
+            return ! in_array($key, ['driver', 'username'], true);
+        }, ARRAY_FILTER_USE_KEY);
+    }
+
+    /**
+     * Return all of the created connections.
+     *
+     * @return array
+     */
+    public function connections()
+    {
+        return $this->connections;
+    }
+
+    /**
+     * Enable the firing of Redis command events.
+     *
+     * @return void
+     */
+    public function enableEvents()
+    {
+        $this->events = true;
+    }
+
+    /**
+     * Disable the firing of Redis command events.
+     *
+     * @return void
+     */
+    public function disableEvents()
+    {
+        $this->events = false;
+    }
+
+    /**
+     * Set the default driver.
+     *
+     * @param  string  $driver
+     * @return void
+     */
+    public function setDriver($driver)
+    {
+        $this->driver = $driver;
+    }
+
+    /**
+     * Register a custom driver creator Closure.
+     *
+     * @param  string  $driver
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    public function extend($driver, Closure $callback)
+    {
+        $this->customCreators[$driver] = $callback->bindTo($this, $this);
+
+        return $this;
+    }
+
+    /**
+     * Pass methods onto the default Redis connection.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->connection()->{$method}(...$parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Redis/RedisServiceProvider.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Redis;
+
+use Illuminate\Contracts\Support\DeferrableProvider;
+use Illuminate\Support\Arr;
+use Illuminate\Support\ServiceProvider;
+
+class RedisServiceProvider extends ServiceProvider implements DeferrableProvider
+{
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->app->singleton('redis', function ($app) {
+            $config = $app->make('config')->get('database.redis', []);
+
+            return new RedisManager($app, Arr::pull($config, 'client', 'phpredis'), $config);
+        });
+
+        $this->app->bind('redis.connection', function ($app) {
+            return $app['redis']->connection();
+        });
+    }
+
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides()
+    {
+        return ['redis', 'redis.connection'];
+    }
+}

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

@@ -0,0 +1,39 @@
+{
+    "name": "illuminate/redis",
+    "description": "The Illuminate Redis package.",
+    "license": "MIT",
+    "homepage": "https://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylor@laravel.com"
+        }
+    ],
+    "require": {
+        "php": "^7.2.5|^8.0",
+        "illuminate/contracts": "^7.0",
+        "illuminate/support": "^7.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Redis\\": ""
+        }
+    },
+    "suggest": {
+        "ext-redis": "Required to use the phpredis connector (^4.0|^5.0).",
+        "predis/predis": "Required to use the predis connector (^1.1.2)."
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "7.x-dev"
+        }
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "minimum-stability": "dev"
+}