added redis module

sites/all/modules/contrib/dev/redis/.gitignore

@@ -0,0 +1 @@
+predis

sites/all/modules/contrib/dev/redis/.travis-before-script.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -e $DRUPAL_TI_DEBUG
+
+# Ensure the right Drupal version is installed.
+# Note: This function is re-entrant.
+drupal_ti_ensure_drupal
+
+# Add needed dependencies.
+cd "$DRUPAL_TI_DRUPAL_DIR"
+
+# Download predis
+composer require predis/predis
+
+
+# These variables come from environments/drupal-*.sh
+mkdir -p "$DRUPAL_TI_MODULES_PATH"
+cd "$DRUPAL_TI_MODULES_PATH"
+
+#Enable php-redis
+echo "extension = redis.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini

sites/all/modules/contrib/dev/redis/.travis.yml

@@ -0,0 +1,119 @@
+# @file
+# .travis.yml - Drupal for Travis CI Integration
+#
+# Template provided by https://github.com/LionsAd/drupal_ti.
+#
+# Based for simpletest upon:
+#   https://github.com/sonnym/travis-ci-drupal-module-example
+
+language: php
+
+php:
+  - 5.5
+  - 5.6
+  - 7
+  - hhvm
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - php: hhvm
+
+env:
+  global:
+    # add composer's global bin directory to the path
+    # see: https://github.com/drush-ops/drush#install---composer
+    - PATH="$PATH:$HOME/.composer/vendor/bin"
+
+    # Configuration variables.
+    - DRUPAL_TI_MODULE_NAME="redis"
+    - DRUPAL_TI_SIMPLETEST_GROUP="redis"
+
+    # Define runners and environment vars to include before and after the
+    # main runners / environment vars.
+    #- DRUPAL_TI_SCRIPT_DIR_BEFORE="./.drupal_ti/before"
+    #- DRUPAL_TI_SCRIPT_DIR_AFTER="./drupal_ti/after"
+
+    # The environment to use, supported are: drupal-7, drupal-8
+    - DRUPAL_TI_ENVIRONMENT="drupal-8"
+
+    # Drupal specific variables.
+    - DRUPAL_TI_DB="drupal_travis_db"
+    - DRUPAL_TI_DB_URL="mysql://root:@127.0.0.1/drupal_travis_db"
+    # Note: Do not add a trailing slash here.
+    - DRUPAL_TI_WEBSERVER_URL="http://127.0.0.1"
+    - DRUPAL_TI_WEBSERVER_PORT="8080"
+
+    # Simpletest specific commandline arguments, the DRUPAL_TI_SIMPLETEST_GROUP is appended at the end.
+    - DRUPAL_TI_SIMPLETEST_ARGS="--verbose --color --concurrency 4 --url $DRUPAL_TI_WEBSERVER_URL:$DRUPAL_TI_WEBSERVER_PORT"
+
+    # === Behat specific variables.
+    # This is relative to $TRAVIS_BUILD_DIR
+    - DRUPAL_TI_BEHAT_DIR="./tests/behat"
+    # These arguments are passed to the bin/behat command.
+    - DRUPAL_TI_BEHAT_ARGS=""
+    # Specify the filename of the behat.yml with the $DRUPAL_TI_DRUPAL_DIR variables.
+    - DRUPAL_TI_BEHAT_YML="behat.yml.dist"
+    # This is used to setup Xvfb.
+    - DRUPAL_TI_BEHAT_SCREENSIZE_COLOR="1280x1024x16"
+    # The version of seleniumthat should be used.
+    - DRUPAL_TI_BEHAT_SELENIUM_VERSION="2.44"
+    # Set DRUPAL_TI_BEHAT_DRIVER to "selenium" to use "firefox" or "chrome" here.
+    - DRUPAL_TI_BEHAT_DRIVER="phantomjs"
+    - DRUPAL_TI_BEHAT_BROWSER="firefox"
+
+    # Use Drupal 8.3.x to run tests.
+    - DRUPAL_TI_CORE_BRANCH="8.3.x"
+
+    # PHPUnit specific commandline arguments.
+    - DRUPAL_TI_PHPUNIT_ARGS="--verbose --debug"
+    # Specifying the phpunit-core src/ directory is useful when e.g. a vendor/
+    # directory is present in the module directory, which phpunit would then
+    # try to find tests in. This option is relative to $TRAVIS_BUILD_DIR.
+    #- DRUPAL_TI_PHPUNIT_CORE_SRC_DIRECTORY="./tests/src"
+
+    # Code coverage via coveralls.io
+    - DRUPAL_TI_COVERAGE="satooshi/php-coveralls:0.6.*"
+    # This needs to match your .coveralls.yml file.
+    - DRUPAL_TI_COVERAGE_FILE="build/logs/clover.xml"
+
+    # Debug options
+    #- DRUPAL_TI_DEBUG="-x -v"
+    # Set to "all" to output all files, set to e.g. "xvfb selenium" or "selenium",
+    # etc. to only output those channels.
+    #- DRUPAL_TI_DEBUG_FILE_OUTPUT="selenium xvfb webserver"
+
+    # [[[ SELECT ANY OR MORE OPTIONS ]]]
+    #- DRUPAL_TI_RUNNERS="phpunit"
+    #- DRUPAL_TI_RUNNERS="simpletest"
+    #- DRUPAL_TI_RUNNERS="behat"
+    - DRUPAL_TI_RUNNERS="phpunit-core"
+  matrix:
+    - REDIS_INTERFACE=PhpRedis
+    - REDIS_INTERFACE=Predis
+
+# This will create the database
+mysql:
+  database: drupal_travis_db
+  username: root
+  encoding: utf8
+
+services:
+  - redis-server
+
+before_install:
+  - composer global require "lionsad/drupal_ti:dev-master#396d11d200005eb68491d24170da0a98ae7f51b3"
+  - drupal-ti before_install
+
+install:
+  - drupal-ti install
+
+before_script:
+  - drupal-ti --include .travis-before-script.sh
+  - drupal-ti before_script
+
+script:
+  - drupal-ti script
+
+after_script:
+  - drupal-ti after_script

sites/all/modules/contrib/dev/redis/LICENSE.txt

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

sites/all/modules/contrib/dev/redis/README.PhpRedis.txt

@@ -0,0 +1,52 @@
+PhpRedis cache backend
+======================
+
+This client, for now, is only able to use the PhpRedis extension.
+
+Get PhpRedis
+------------
+
+You can download this library at:
+
+  https://github.com/nicolasff/phpredis
+
+This is PHP extension, too recent for being packaged in most distribution, you
+will probably need to compile it yourself.
+
+Default behavior is to connect via tcp://localhost:6379 but you might want to
+connect differently.
+
+Use the Sentinel high availability mode
+---------------------------------------
+
+Redis can provide a master/slave mode with sentinels server monitoring them.
+More information about setting it : https://redis.io/topics/sentinel.
+
+This mode needs the following settings:
+
+Modify the host as follow:
+    // Sentinels instances list with hostname:port format.
+    $settings['redis.connection']['host']      = ['1.2.3.4:5000','1.2.3.5:5000','1.2.3.6:5000'];
+
+Add the new instance setting:
+
+    // Redis instance name.
+    $settings['redis.connection']['instance']  = 'instance_name';
+
+Connect via UNIX socket
+-----------------------
+
+Just add this line to your settings.php file:
+
+  $conf['redis_cache_socket'] = '/tmp/redis.sock';
+
+Don't forget to change the path depending on your operating system and Redis
+server configuration.
+
+Connect to a remote host and database
+-------------------------------------
+
+See README.md file.
+
+For this particular implementation, host settings are overridden by the
+UNIX socket parameter.

sites/all/modules/contrib/dev/redis/README.Predis.txt

@@ -0,0 +1,37 @@
+Predis cache backend
+====================
+
+Using Predis for the Drupal 8 version of this module is still experimental.
+
+Get Predis
+----------
+
+Predis can be installed to the vendor directory using composer like so:
+
+composer require nrk/predis
+
+
+Configuration of module for use with Predis
+----------------------------
+
+There is not much different to configure about Predis.
+Adding this to settings.php should suffice for basic usage:
+
+$settings['redis.connection']['interface'] = 'Predis';
+$settings['redis.connection']['host']      = '1.2.3.4';  // Your Redis instance hostname.
+$settings['cache']['default'] = 'cache.backend.redis';
+
+To add more magic with a primary/replica setup you can use a config like this:
+
+$settings['redis.connection']['interface'] = 'Predis'; // Use predis library.
+$settings['redis.connection']['replication'] = TRUE; // Turns on replication.
+$settings['redis.connection']['replication.host'][1]['host'] = '1.2.3.4';  // Your Redis instance hostname.
+$settings['redis.connection']['replication.host'][1]['port'] = '6379'; // Only required if using non-standard port.
+$settings['redis.connection']['replication.host'][1]['role'] = 'primary'; // The redis instance role.
+$settings['redis.connection']['replication.host'][2]['host'] = '1.2.3.5';
+$settings['redis.connection']['replication.host'][2]['port'] = '6379';
+$settings['redis.connection']['replication.host'][2]['role'] = 'replica';
+$settings['redis.connection']['replication.host'][3]['host'] = '1.2.3.6';
+$settings['redis.connection']['replication.host'][3]['port'] = '6379';
+$settings['redis.connection']['replication.host'][3]['role'] = 'replica';
+$settings['cache']['default'] = 'cache.backend.redis';

sites/all/modules/contrib/dev/redis/README.md

@@ -0,0 +1,338 @@
+Redis backends
+====================
+
+This package provides two different Redis backends. If you want to use
+Redis as cache backend, you have to choose one of the two, but you cannot use
+both at the same time.
+
+PhpRedis
+--------
+
+This implementation uses the PhpRedis PHP extension. In order to use it, you
+will need to compile the extension yourself.
+
+Predis
+------
+
+Support for the Predis PHP library is experimental, but feel free to try it out. 
+You can install the required library using composer. Check out the README.Predis.txt file 
+for more information.
+
+Important notice
+----------------
+
+This module requires at least Redis 2.4, additionally, the lock backend
+requires Redis 2.6 to support millisecond timeouts and atomic lock operations.
+
+Getting started
+===============
+
+Quick setup
+-----------
+
+Here is a simple yet working easy way to setup the module.
+
+This method will allow Drupal to use Redis for all caches.
+
+    $settings['redis.connection']['interface'] = 'PhpRedis'; // Can be "Predis".
+    $settings['redis.connection']['host']      = '1.2.3.4';  // Your Redis instance hostname.
+    $settings['cache']['default'] = 'cache.backend.redis';
+
+To use some Predis goodness, including a redis primary/replica setup you can use a config like this.
+
+    $settings['redis.connection']['interface'] = 'Predis'; // Use predis library.
+    $settings['redis.connection']['replication'] = TRUE; // Turns on replication.
+    $settings['redis.connection']['replication.host'][1]['host'] = '1.2.3.4';  // Your Redis instance hostname.
+    $settings['redis.connection']['replication.host'][1]['port'] = '6379'; // Only required if using non-standard port.
+    $settings['redis.connection']['replication.host'][1]['role'] = 'primary'; // The redis instance role.
+    $settings['redis.connection']['replication.host'][2]['host'] = '1.2.3.5';
+    $settings['redis.connection']['replication.host'][2]['port'] = '6379';
+    $settings['redis.connection']['replication.host'][2]['role'] = 'replica';
+    $settings['redis.connection']['replication.host'][3]['host'] = '1.2.3.6';
+    $settings['redis.connection']['replication.host'][3]['port'] = '6379';
+    $settings['redis.connection']['replication.host'][3]['role'] = 'replica';
+    $settings['cache']['default'] = 'cache.backend.redis';
+
+Either include the default example.services.yml from the module, which will
+replace all supported backend services (that currently includes the cache tags
+checksum service and the lock backends, check the file for the current list)
+or copy the service definitions into a site specific services.yml.
+
+    $settings['container_yamls'][] = 'modules/redis/example.services.yml';
+
+Note that for any of this, the redis module must be enabled. See next chapters
+for more information.
+
+Is there any cache bins that should *never* go into Redis?
+----------------------------------------------------------
+
+TL;DR: No.
+
+Redis has been maturing a lot over time, and will apply different sensible
+settings for different bins; It's today very stable.
+
+Advanced configuration
+======================
+
+Choose the Redis client library to use
+--------------------------------------
+
+Note: This is not yet supported, only the PhpRedis interface is available.
+
+Add into your settings.php file:
+
+    $settings['redis.connection']['interface'] = 'PhpRedis';
+
+You can replace 'PhpRedis' with 'Predis', depending on the library you chose. 
+
+
+Tell Drupal to use the cache backend
+------------------------------------
+
+Usual cache backend configuration, as follows, to add into your settings.php
+file like any other backend:
+
+    # Use for all bins otherwise specified.
+    $settings['cache']['default'] = 'cache.backend.redis';
+  
+    # Use this to only use it for specific cache bins.
+    $settings['cache']['bins']['render'] = 'cache.backend.redis';
+
+Tell Drupal to use the lock backend
+-----------------------------------
+
+See the provided example.services.yml file on how to override the lock services.
+
+Tell Drupal to use the queue backend
+------------------------------------
+
+This module provides reliable and non-reliable queue implementations. Depending
+on which is to be use you need to choose "queue.redis" or "queue.redis_reliable"
+as a service name.
+
+When you have configured basic information (host, library, ... - see Quick setup)
+add this to your settings.php file:
+
+    # Use for all queues unless otherwise specified for a specific queue.
+    $settings['queue_default'] = 'queue.redis';
+
+    # Or if you want to use reliable queue implementation.
+    $settings['queue_default'] = 'queue.redis_reliable';
+
+
+    # Use this to only use Redis for a specific queue (aggregator_feeds in this case).
+    $settings['queue_service_aggregator_feeds'] = 'queue.redis';
+
+    # Or if you want to use reliable queue implementation.
+    $settings['queue_service_aggregator_feeds'] = 'queue.redis_reliable';
+
+
+Common settings
+===============
+
+Connect to a remote host
+------------------------
+
+If your Redis instance is remote, you can use this syntax:
+
+    $settings['redis.connection']['interface'] = 'PhpRedis'; // Can be "Predis".
+    $settings['redis.connection']['host']      = '1.2.3.4';  // Your Redis instance hostname.
+    $settings['redis.connection']['port']      = '6379';  // Redis port
+
+Port is optional, default is 6379 (default Redis port).
+
+Using a specific database
+-------------------------
+
+Per default, Redis ships the database "0". All default connections will be use
+this one if nothing is specified.
+
+Depending on you OS or OS distribution, you might have numerous database. To
+use one in particular, just add to your settings.php file:
+
+    $settings['redis.connection']['base']      = 12;
+
+Connection to a password protected instance
+-------------------------------------------
+
+If you are using a password protected instance, specify the password this way:
+
+    $settings['redis.connection']['password'] = "mypassword";
+
+Depending on the backend, using a wrong auth will behave differently:
+
+ - Predis will throw an exception and make Drupal fail during early boostrap.
+
+ - PhpRedis will make Redis calls silent and creates some PHP warnings, thus
+   Drupal will behave as if it was running with a null cache backend (no cache
+   at all).
+
+Prefixing site cache entries (avoiding sites name collision)
+------------------------------------------------------------
+
+If you need to differentiate multiple sites using the same Redis instance and
+database, you will need to specify a prefix for your site cache entries.
+
+Cache prefix configuration attempts to use a unified variable across contrib
+backends that support this feature. This variable name is 'cache_prefix'.
+
+This variable is polymorphic, the simplest version is to provide a raw string
+that will be the default prefix for all cache bins:
+
+    $settings['cache_prefix'] = 'mysite_';
+
+Alternatively, to provide the same functionality, you can provide the variable
+as an array:
+
+    $settings['cache_prefix']['default'] = 'mysite_';
+
+This allows you to provide different prefix depending on the bin name. Common
+usage is that each key inside the 'cache_prefix' array is a bin name, the value
+the associated prefix. If the value is FALSE, then no prefix is
+used for this bin.
+
+The 'default' meta bin name is provided to define the default prefix for non
+specified bins. It behaves like the other names, which means that an explicit
+FALSE will order the backend not to provide any prefix for any non specified
+bin.
+
+Here is a complex sample:
+
+    // Default behavior for all bins, prefix is 'mysite_'.
+    $settings['cache_prefix']['default'] = 'mysite_';
+  
+    // Set no prefix explicitely for 'cache' and 'cache_bootstrap' bins.
+    $settings['cache_prefix']['cache'] = FALSE;
+    $settings['cache_prefix']['cache_bootstrap'] = FALSE;
+  
+    // Set another prefix for 'cache_menu' bin.
+    $settings['cache_prefix']['cache_menu'] = 'menumysite_';
+
+Note that if you don't specify the default behavior, the Redis module will
+attempt to use the HTTP_HOST variable in order to provide a multisite safe
+default behavior. Notice that this is not failsafe, in such environment you
+are strongly advised to set at least an explicit default prefix.
+
+Note that this last notice is Redis only specific, because per default Redis
+server will not namespace data, thus sharing an instance for multiple sites
+will create conflicts. This is not true for every contributed backends.
+
+Flush mode
+----------
+
+@todo: Update for Drupal 8
+
+Redis allows to set a time-to-live at the key level, which frees us from
+handling the garbage collection at clear() calls; Unfortunately Drupal never
+explicitely clears single cached pages or blocks. If you didn't configure the
+"cache_lifetime" core variable, its value is "0" which means that temporary
+items never expire: in this specific case, we need to adopt a different
+behavior than leting Redis handling the TTL by itself; This is why we have
+three different implementations of the flush algorithm you can use:
+
+ * 0: Never flush temporary: leave Redis handling the TTL; This mode is
+   not compatible for the "page" and "block" bins but is the default for
+   all others.
+
+ * 1: Keep a copy of temporary items identifiers in a SET and flush them
+   accordingly to spec (DatabaseCache default backend mimic behavior):
+   this is the default for "page" and "block" bin if you don't change the
+   configuration.
+
+ * 2: Flush everything including permanent or valid items on clear() calls:
+   this behavior mimics the pre-1.0 releases of this module. Use it only
+   if you experience backward compatibility problems on a production
+   environement - at the cost of potential performance issues; All other
+   users should ignore this parameter.
+
+You can configure a default flush mode which will override the sensible
+provided defaults by setting the 'redis_flush_mode' variable.
+
+  // For example this is the safer mode.
+  $conf['redis_flush_mode'] = 1;
+
+But you may also want to change the behavior for only a few bins.
+
+  // This will put mode 0 on "bootstrap" bin.
+  $conf['redis_flush_mode_cache_bootstrap'] = 0;
+
+  // And mode 2 to "page" bin.
+  $conf['redis_flush_mode_cache_page'] = 2;
+
+Note that you must prefix your bins with "cache" as the Drupal 7 bin naming
+convention requires it.
+
+Keep in mind that defaults will provide the best balance between performance
+and safety for most sites; Non advanced users should ever change them.
+
+Default lifetime for permanent items
+------------------------------------
+
+@todo: Update for Drupal 8
+
+Redis when reaching its maximum memory limit will stop writing data in its
+storage engine: this is a feature that avoid the Redis server crashing when
+there is no memory left on the machine.
+
+As a workaround, Redis can be configured as a LRU cache for both volatile or
+permanent items, which means it can behave like Memcache; Problem is that if
+you use Redis as a permanent storage for other business matters than this
+module you cannot possibly configure it to drop permanent items or you'll
+loose data.
+
+This workaround allows you to explicity set a very long or configured default
+lifetime for CACHE_PERMANENT items (that would normally be permanent) which
+will mark them as being volatile in Redis storage engine: this then allows you
+to configure a LRU behavior for volatile keys without engaging the permenent
+business stuff in a dangerous LRU mechanism; Cache items even if permament will
+be dropped when unused using this.
+
+Per default the TTL for permanent items will set to safe-enough value which is
+one year; No matter how Redis will be configured default configuration or lazy
+admin will inherit from a safe module behavior with zero-conf.
+
+For advanturous people, you can manage the TTL on a per bin basis and change
+the default one:
+
+    // Make CACHE_PERMANENT items being permanent once again
+    // 0 is a special value usable for all bins to explicitely tell the
+    // cache items will not be volatile in Redis.
+    $conf['redis_perm_ttl'] = 0;
+
+    // Make them being volatile with a default lifetime of 1 year.
+    $conf['redis_perm_ttl'] = "1 year";
+
+    // You can override on a per-bin basis;
+    // For example make cached field values live only 3 monthes:
+    $conf['redis_perm_ttl_cache_field'] = "3 months";
+
+    // But you can also put a timestamp in there; In this case the
+    // value must be a STRICTLY TYPED integer:
+    $conf['redis_perm_ttl_cache_field'] = 2592000; // 30 days.
+
+Time interval string will be parsed using DateInterval::createFromDateString
+please refer to its documentation:
+
+    http://www.php.net/manual/en/dateinterval.createfromdatestring.php
+
+Last but not least please be aware that this setting affects the
+CACHE_PERMANENT ONLY; All other use cases (CACHE_TEMPORARY or user set TTL
+on single cache entries) will continue to behave as documented in Drupal core
+cache backend documentation.
+
+Lock backends
+-------------
+
+@todo: Update for Drupal 8
+
+Both implementations provides a Redis lock backend. Redis lock backend proved to
+be faster than the default SQL based one when using both servers on the same box.
+
+Both backends, thanks to the Redis WATCH, MULTI and EXEC commands provides a
+real race condition free mutexes if you use Redis >= 2.1.0.
+
+Testing
+=======
+
+I did not find any hint about making tests being configurable, so per default
+the tested Redis server must always be on localhost with default configuration.

sites/all/modules/contrib/dev/redis/composer.json

@@ -0,0 +1,13 @@
+{
+  "name": "drupal/redis",
+  "type": "drupal-module",
+  "suggest": {
+    "predis/predis": "^1.1.1"
+  },
+  "license": "GPL-2.0",
+  "autoload": {
+    "psr-4": {
+      "Drupal\\redis\\": "src"
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/example.services.yml

@@ -0,0 +1,33 @@
+# This file contains example services overrides.
+#
+# Enable with this line in settings.php
+#   $settings['container_yamls'][] = 'modules/redis/example.services.yml';
+#
+# Or copy & paste the desired services into sites/default/services.yml.
+#
+# Note that the redis module must be enabled for this to work.
+
+services:
+  # Cache tag checksum backend. Used by redis and most other cache backend
+  # to deal with cache tag invalidations.
+  cache_tags.invalidator.checksum:
+   class: Drupal\redis\Cache\RedisCacheTagsChecksum
+   arguments: ['@redis.factory']
+   tags:
+     - { name: cache_tags_invalidator }
+
+  # Replaces the default lock backend with a redis implementation.
+  lock:
+    class: Drupal\Core\Lock\LockBackendInterface
+    factory: ['@redis.lock.factory', get]
+
+  # Replaces the default persistent lock backend with a redis implementation.
+  lock.persistent:
+    class: Drupal\Core\Lock\LockBackendInterface
+    factory: ['@redis.lock.factory', get]
+    arguments: [true]
+
+  # Replaces the default flood backend with a redis implementation.
+  flood:
+    class: Drupal\Core\Flood\FloodInterface
+    factory: ['@redis.flood.factory', get]

sites/all/modules/contrib/dev/redis/redis.info.yml

@@ -0,0 +1,12 @@
+name: Redis
+description: Provide a module placeholder, for using as dependency for module that needs Redis.
+package: Performance
+type: module
+# core: 8.x
+configure: redis.admin_display
+
+# Information added by Drupal.org packaging script on 2017-09-14
+version: '8.x-1.0-rc2'
+core: '8.x'
+project: 'redis'
+datestamp: 1505390051

sites/all/modules/contrib/dev/redis/redis.install

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @file
+ * Redis install related functions.
+ */
+
+use \Drupal\redis\ClientFactory;
+
+/**
+ * Implements hook_requirements().
+ */
+function redis_requirements($phase) {
+
+  // This module is configured via settings.php file. Using any other phase
+  // than runtime to proceed to some consistency checks is useless.
+  if ('runtime' !== $phase) {
+    return [];
+  }
+
+  $requirements = [];
+
+  if (ClientFactory::hasClient()) {
+    $requirements['redis'] = [
+      'title'       => "Redis",
+      'value'       => t("Connected, using the <em>@name</em> client.", ['@name' => ClientFactory::getClientName()]),
+      'severity'    => REQUIREMENT_OK,
+    ];
+  }
+  else {
+    $requirements['redis'] = [
+      'title'       => "Redis",
+      'value'       => t("Not connected."),
+      'severity'    => REQUIREMENT_WARNING,
+      'description' => t("No Redis client connected, this module is useless thereof. Ensure that you enabled module using it or disable it."),
+    ];
+  }
+
+  return $requirements;
+}

sites/all/modules/contrib/dev/redis/redis.module

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * @file
+ * Redis module.
+ *
+ * This file is a placeholder for other modules that need the Redis client for
+ * something else than lock and cache.
+ */
+
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\redis\ClientFactory;
+
+/**
+ * Implements hook_help().
+ */
+function redis_help($route_name, RouteMatchInterface $route_match) {
+  switch ($route_name) {
+    case 'help.page.redis':
+      if (ClientFactory::hasClient()) {
+        $messages = '<p><strong>' . t("Current connected client uses the <em>@name</em> library.", ['@name' => ClientFactory::getClientName()]) . '</strong></p>';
+      }
+      else {
+        $messages = '<p><strong>' . t('No redis connection configured.') . '</strong></p>';
+      }
+      return $messages;
+  }
+}

sites/all/modules/contrib/dev/redis/redis.services.yml

@@ -0,0 +1,18 @@
+services:
+  cache.backend.redis:
+    class: Drupal\redis\Cache\CacheBackendFactory
+    arguments: ['@redis.factory', '@cache_tags.invalidator.checksum', '@serialization.phpserialize']
+  redis.factory:
+    class: Drupal\redis\ClientFactory
+  redis.lock.factory:
+    class: Drupal\redis\Lock\LockFactory
+    arguments: ['@redis.factory']
+  redis.flood.factory:
+    class: Drupal\redis\Flood\FloodFactory
+    arguments: ['@redis.factory', '@request_stack']
+  queue.redis_reliable:
+    class: Drupal\redis\Queue\ReliableQueueRedisFactory
+    arguments: ['@redis.factory', '@settings']
+  queue.redis:
+    class: Drupal\redis\Queue\QueueRedisFactory
+    arguments: ['@redis.factory', '@settings']

sites/all/modules/contrib/dev/redis/src/Cache/CacheBackendFactory.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Drupal\redis\Cache;
+
+use Drupal\Component\Serialization\SerializationInterface;
+use Drupal\Core\Cache\CacheFactoryInterface;
+use Drupal\Core\Cache\CacheTagsChecksumInterface;
+use Drupal\redis\ClientFactory;
+
+/**
+ * A cache backend factory responsible for the construction of redis cache bins.
+ */
+class CacheBackendFactory implements CacheFactoryInterface {
+
+  /**
+   * @var \Drupal\redis\ClientInterface
+   */
+  protected $clientFactory;
+
+  /**
+   * The cache tags checksum provider.
+   *
+   * @var \Drupal\Core\Cache\CacheTagsChecksumInterface
+   */
+  protected $checksumProvider;
+
+  /**
+   * The serialization class to use.
+   *
+   * @var \Drupal\Component\Serialization\SerializationInterface
+   */
+  protected $serializer;
+
+  /**
+   * List of cache bins.
+   *
+   * Renderer and possibly other places fetch backends directly from the
+   * factory. Avoid that the backend objects have to fetch meta information like
+   * the last delete all timestamp multiple times.
+   *
+   * @var array
+   */
+  protected $bins = [];
+
+  /**
+   * Creates a redis CacheBackendFactory.
+   *
+   * @param \Drupal\redis\ClientFactory $client_factory
+   * @param \Drupal\Core\Cache\CacheTagsChecksumInterface $checksum_provider
+   * @param \Drupal\redis\Cache\SerializationInterface $serializer
+   *   The serialization class to use.
+   */
+  public function __construct(ClientFactory $client_factory, CacheTagsChecksumInterface $checksum_provider, SerializationInterface $serializer) {
+    $this->clientFactory = $client_factory;
+    $this->checksumProvider = $checksum_provider;
+    $this->serializer = $serializer;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function get($bin) {
+    if (!isset($this->bins[$bin])) {
+      $class_name = $this->clientFactory->getClass(ClientFactory::REDIS_IMPL_CACHE);
+      $this->bins[$bin] = new $class_name($bin, $this->clientFactory->getClient(), $this->checksumProvider, $this->serializer);
+    }
+    return $this->bins[$bin];
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Cache/CacheBase.php

@@ -0,0 +1,378 @@
+<?php
+
+namespace Drupal\redis\Cache;
+
+use \DateInterval;
+use Drupal\Component\Serialization\SerializationInterface;
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Site\Settings;
+use Drupal\redis\RedisPrefixTrait;
+
+/**
+ * Base class for redis cache backends.
+ *
+ *  *
+ *
+ */
+abstract class CacheBase implements CacheBackendInterface {
+
+  use RedisPrefixTrait;
+
+  /**
+   * Temporary cache items lifetime is infinite.
+   */
+  const LIFETIME_INFINITE = 0;
+
+  /**
+   * Default lifetime for permanent items.
+   * Approximatively 1 year.
+   */
+  const LIFETIME_PERM_DEFAULT = 31536000;
+
+  /**
+   * Computed keys are let's say arround 60 characters length due to
+   * key prefixing, which makes 1,000 keys DEL command to be something
+   * arround 50,000 bytes length: this is huge and may not pass into
+   * Redis, let's split this off.
+   * Some recommend to never get higher than 1,500 bytes within the same
+   * command which makes us forced to split this at a very low threshold:
+   * 20 seems a safe value here (1,280 average length).
+   */
+  const KEY_THRESHOLD = 20;
+
+  /**
+   * Latest delete all flush KEY name.
+   */
+  const LAST_DELETE_ALL_KEY = '_redis_last_delete_all';
+
+  /**
+   * @var string
+   */
+  protected $bin;
+
+  /**
+   * The serialization class to use.
+   *
+   * @var \Drupal\Component\Serialization\SerializationInterface
+   */
+  protected $serializer;
+
+  /**
+   * Default TTL for CACHE_PERMANENT items.
+   *
+   * See "Default lifetime for permanent items" section of README.md
+   * file for a comprehensive explaination of why this exists.
+   *
+   * @var int
+   */
+  protected $permTtl = self::LIFETIME_PERM_DEFAULT;
+
+  /**
+   * Minimal TTL to use.
+   *
+   * Note that this is for testing purposes. Do not specify the minimal TTL
+   * outside of unit-tests.
+   */
+  protected $minTtl = 0;
+
+  /**
+   * @var \Drupal\redis\ClientInterface
+   */
+  protected $client;
+
+  /**
+   * The cache tags checksum provider.
+   *
+   * @var \Drupal\Core\Cache\CacheTagsChecksumInterface|\Drupal\Core\Cache\CacheTagsInvalidatorInterface
+   */
+  protected $checksumProvider;
+
+  /**
+   * The last delete timestamp.
+   *
+   * @var float
+   */
+  protected $lastDeleteAll = NULL;
+
+  /**
+   * Get TTL for CACHE_PERMANENT items.
+   *
+   * @return int
+   *   Lifetime in seconds.
+   */
+  public function getPermTtl() {
+    return $this->permTtl;
+  }
+
+  /**
+   * CacheBase constructor.
+   * @param $bin
+   *   The cache bin for which the object is created.
+   * @param \Drupal\Component\Serialization\SerializationInterface $serializer
+   *   The serialization class to use.
+   */
+  public function __construct($bin, SerializationInterface $serializer) {
+    $this->bin = $bin;
+    $this->serializer = $serializer;
+    $this->setPermTtl();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function get($cid, $allow_invalid = FALSE) {
+    $cids = [$cid];
+    $cache = $this->getMultiple($cids, $allow_invalid);
+    return reset($cache);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setMultiple(array $items) {
+    foreach ($items as $cid => $item) {
+      $this->set($cid, $item['data'], isset($item['expire']) ? $item['expire'] : CacheBackendInterface::CACHE_PERMANENT, isset($item['tags']) ? $item['tags'] : []);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function delete($cid) {
+    $this->deleteMultiple([$cid]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function removeBin() {
+    $this->deleteAll();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidate($cid) {
+    $this->invalidateMultiple([$cid]);
+  }
+
+  /**
+   * Return the key for the given cache key.
+   */
+  public function getKey($cid = NULL) {
+    if (NULL === $cid) {
+      return $this->getPrefix() . ':' . $this->bin;
+    }
+    else {
+      return $this->getPrefix() . ':' . $this->bin . ':' . $cid;
+    }
+  }
+
+  /**
+   * Calculate the correct expiration time.
+   *
+   * @param int $expire
+   *   The expiration time provided for the cache set.
+   *
+   * @return int
+   *   The default expiration if expire is PERMANENT or higher than the default.
+   *   May return negative values if the item is already expired.
+   */
+  protected function getExpiration($expire) {
+    if ($expire == Cache::PERMANENT || $expire > $this->permTtl) {
+      return $this->permTtl;
+    }
+    return $expire - REQUEST_TIME;
+  }
+
+  /**
+   * Return the key for the tag used to specify the bin of cache-entries.
+   */
+  protected function getTagForBin() {
+    return 'x-redis-bin:' . $this->bin;
+  }
+
+  /**
+   * Set the minimum TTL (unit testing only).
+   */
+  public function setMinTtl($ttl) {
+    $this->minTtl = $ttl;
+  }
+
+  /**
+   * Set the permanent TTL.
+   */
+  public function setPermTtl($ttl = NULL) {
+    if (isset($ttl)) {
+      $this->permTtl = $ttl;
+    }
+    else {
+      // Attempt to set from settings.
+      if (($settings = Settings::get('redis.settings', [])) && isset($settings['perm_ttl_' . $this->bin])) {
+        $ttl = $settings['perm_ttl_' . $this->bin];
+        if ($ttl === (int) $ttl) {
+          $this->permTtl = $ttl;
+        }
+        else {
+          if ($iv = DateInterval::createFromDateString($ttl)) {
+            // http://stackoverflow.com/questions/14277611/convert-dateinterval-object-to-seconds-in-php
+            $this->permTtl = ($iv->y * 31536000 + $iv->m * 2592000 + $iv->days * 86400 + $iv->h * 3600 + $iv->i * 60 + $iv->s);
+          }
+          else {
+            // Log error about invalid ttl.
+            trigger_error(sprintf("Parsed TTL '%s' has an invalid value: switching to default", $ttl));
+            $this->permTtl = self::LIFETIME_PERM_DEFAULT;
+          }
+
+        }
+      }
+    }
+  }
+
+  /**
+   * Prepares a cached item.
+   *
+   * Checks that items are either permanent or did not expire, and unserializes
+   * data as appropriate.
+   *
+   * @param array $values
+   *   The hash returned from redis or false.
+   * @param bool $allow_invalid
+   *   If FALSE, the method returns FALSE if the cache item is not valid.
+   *
+   * @return mixed|false
+   *   The item with data unserialized as appropriate and a property indicating
+   *   whether the item is valid, or FALSE if there is no valid item to load.
+   */
+  protected function expandEntry(array $values, $allow_invalid) {
+    // Check for entry being valid.
+    if (empty($values['cid'])) {
+      return FALSE;
+    }
+
+    $cache = (object) $values;
+
+    $cache->tags = explode(' ', $cache->tags);
+
+    // Check expire time, allow to have a cache invalidated explicitly, don't
+    // check if already invalid.
+    if ($cache->valid) {
+      $cache->valid = $cache->expire == Cache::PERMANENT || $cache->expire >= REQUEST_TIME;
+
+      // Check if invalidateTags() has been called with any of the items's tags.
+      if ($cache->valid && !$this->checksumProvider->isValid($cache->checksum, $cache->tags)) {
+        $cache->valid = FALSE;
+      }
+    }
+
+    // Ensure the entry does not predate the last delete all time.
+    $last_delete_timestamp = $this->getLastDeleteAll();
+    if ($last_delete_timestamp && ((float)$values['created']) < $last_delete_timestamp) {
+      return FALSE;
+    }
+
+    if (!$allow_invalid && !$cache->valid) {
+      return FALSE;
+    }
+
+    if ($cache->serialized) {
+      $cache->data = $this->serializer->decode($cache->data);
+    }
+
+    return $cache;
+  }
+
+  /**
+   * Create cache entry.
+   *
+   * @param string $cid
+   * @param mixed $data
+   * @param int $expire
+   * @param string[] $tags
+   *
+   * @return array
+   */
+  protected function createEntryHash($cid, $data, $expire = Cache::PERMANENT, array $tags) {
+    // Always add a cache tag for the current bin, so that we can use that for
+    // invalidateAll().
+    $tags[] = $this->getTagForBin();
+    assert('\Drupal\Component\Assertion\Inspector::assertAllStrings($tags)', 'Cache Tags must be strings.');
+    $hash = [
+      'cid' => $cid,
+      'created' => round(microtime(TRUE), 3),
+      'expire' => $expire,
+      'tags' => implode(' ', $tags),
+      'valid' => 1,
+      'checksum' => $this->checksumProvider->getCurrentChecksum($tags),
+    ];
+
+    // Let Redis handle the data types itself.
+    if (!is_string($data)) {
+      $hash['data'] = $this->serializer->encode($data);
+      $hash['serialized'] = 1;
+    }
+    else {
+      $hash['data'] = $data;
+      $hash['serialized'] = 0;
+    }
+
+    return $hash;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateMultiple(array $cids) {
+    // Loop over all cache items, they are stored as a hash, so we can access
+    // the valid flag directly, only write if it exists and is not 0.
+    foreach ($cids as $cid) {
+      $key = $this->getKey($cid);
+      if ($this->client->hGet($key, 'valid')) {
+        $this->client->hSet($key, 'valid', 0);
+      }
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateAll() {
+    // To invalidate the whole bin, we invalidate a special tag for this bin.
+    $this->checksumProvider->invalidateTags([$this->getTagForBin()]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function garbageCollection() {
+    // @todo Do we need to do anything here?
+  }
+
+  /**
+   *  Returns the last delete all timestamp.
+   *
+   * @return float
+   *   The last delete timestamp as a timestamp with a millisecond precision.
+   */
+  protected function getLastDeleteAll() {
+    // Cache the last delete all timestamp.
+    if ($this->lastDeleteAll === NULL) {
+      $this->lastDeleteAll = (float) $this->client->get($this->getKey(static::LAST_DELETE_ALL_KEY));
+    }
+    return $this->lastDeleteAll;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteAll() {
+    // The last delete timestamp is in milliseconds, ensure that no cache
+    // was written in the same millisecond.
+    // @todo This is needed to make the tests pass, is this safe enough for real
+    //   usage?
+    usleep(1000);
+    $this->lastDeleteAll = round(microtime(TRUE), 3);
+    $this->client->set($this->getKey(static::LAST_DELETE_ALL_KEY), $this->lastDeleteAll);
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Cache/PhpRedis.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Drupal\redis\Cache;
+
+use Drupal\Component\Serialization\SerializationInterface;
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheTagsChecksumInterface;
+
+/**
+ * PhpRedis cache backend.
+ */
+class PhpRedis extends CacheBase {
+
+  /**
+   * @var \Redis
+   */
+  protected $client;
+
+  /**
+   * Creates a PHpRedis cache backend.
+   *
+   * @param $bin
+   *   The cache bin for which the object is created.
+   * @param \Redis $client
+   * @param \Drupal\Core\Cache\CacheTagsChecksumInterface $checksum_provider
+   * @param \Drupal\redis\Cache\SerializationInterface $serializer
+   *   The serialization class to use.
+   */
+  public function __construct($bin, \Redis $client, CacheTagsChecksumInterface $checksum_provider, SerializationInterface $serializer) {
+    parent::__construct($bin, $serializer);
+    $this->client = $client;
+    $this->checksumProvider = $checksum_provider;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getMultiple(&$cids, $allow_invalid = FALSE) {
+    // Avoid an error when there are no cache ids.
+    if (empty($cids)) {
+      return [];
+    }
+
+    $return = [];
+
+    // Build the list of keys to fetch.
+    $keys = array_map([$this, 'getKey'], $cids);
+
+    // Optimize for the common case when only a single cache entry needs to
+    // be fetched, no pipeline is needed then.
+    if (count($keys) > 1) {
+      $pipe = $this->client->multi(\Redis::PIPELINE);
+      foreach ($keys as $key) {
+        $pipe->hgetall($key);
+      }
+      $result = $pipe->exec();
+    }
+    else {
+      $result = [$this->client->hGetAll(reset($keys))];
+    }
+
+    // Loop over the cid values to ensure numeric indexes.
+    foreach (array_values($cids) as $index => $key) {
+      // Check if a valid result was returned from Redis.
+      if (isset($result[$index]) && is_array($result[$index])) {
+        // Check expiration and invalidation and convert into an object.
+        $item = $this->expandEntry($result[$index], $allow_invalid);
+        if ($item) {
+          $return[$item->cid] = $item;
+        }
+      }
+    }
+
+    // Remove fetched cids from the list.
+    $cids = array_diff($cids, array_keys($return));
+
+    return $return;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = []) {
+
+    $ttl = $this->getExpiration($expire);
+
+    $key = $this->getKey($cid);
+
+    // If the item is already expired, delete it.
+    if ($ttl <= 0) {
+      $this->delete($key);
+    }
+
+    // Build the cache item and save it as a hash array.
+    $entry = $this->createEntryHash($cid, $data, $expire, $tags);
+    $pipe = $this->client->multi(\REdis::PIPELINE);
+    $pipe->hMset($key, $entry);
+    $pipe->expire($key, $ttl);
+    $pipe->exec();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteMultiple(array $cids) {
+    $keys = array_map([$this, 'getKey'], $cids);
+    $this->client->del($keys);
+  }
+
+
+}

sites/all/modules/contrib/dev/redis/src/Cache/Predis.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace Drupal\redis\Cache;
+
+use Drupal\Component\Serialization\SerializationInterface;
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheTagsChecksumInterface;
+
+/**
+ * Predis cache backend.
+ */
+class Predis extends CacheBase {
+
+  /**
+   * @var \Predis\Client
+   */
+  protected $client;
+
+  /**
+   * Creates a Predis cache backend.
+   *
+   * @param $bin
+   *   The cache bin for which the object is created.
+   * @param \Redis $client
+   * @param \Drupal\Core\Cache\CacheTagsChecksumInterface $checksum_provider
+   * @param \Drupal\redis\Cache\SerializationInterface $serializer
+   *   The serialization class to use.
+   */
+  public function __construct($bin, \Predis\Client $client, CacheTagsChecksumInterface $checksum_provider, SerializationInterface $serializer) {
+    parent::__construct($bin, $serializer);
+    $this->client = $client;
+    $this->checksumProvider = $checksum_provider;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getMultiple(&$cids, $allow_invalid = FALSE) {
+    // Avoid an error when there are no cache ids.
+    if (empty($cids)) {
+      return [];
+    }
+
+    $return = [];
+
+    // Build the list of keys to fetch.
+    $keys = array_map([$this, 'getKey'], $cids);
+
+    // Optimize for the common case when only a single cache entry needs to
+    // be fetched, no pipeline is needed then.
+    if (count($keys) > 1) {
+      $pipe = $this->client->pipeline();
+      foreach ($keys as $key) {
+        $pipe->hgetall($key);
+      }
+      $result = $pipe->execute();
+    }
+    else {
+      $result = [$this->client->hGetAll(reset($keys))];
+    }
+
+    // Loop over the cid values to ensure numeric indexes.
+    foreach (array_values($cids) as $index => $key) {
+      // Check if a valid result was returned from Redis.
+      if (isset($result[$index]) && is_array($result[$index])) {
+        // Check expiration and invalidation and convert into an object.
+        $item = $this->expandEntry($result[$index], $allow_invalid);
+        if ($item) {
+          $return[$item->cid] = $item;
+        }
+      }
+    }
+
+    // Remove fetched cids from the list.
+    $cids = array_diff($cids, array_keys($return));
+
+    return $return;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = []) {
+
+    $ttl = $this->getExpiration($expire);
+
+    $key = $this->getKey($cid);
+
+    // If the item is already expired, delete it.
+    if ($ttl <= 0) {
+      $this->delete($key);
+    }
+
+    // Build the cache item and save it as a hash array.
+    $entry = $this->createEntryHash($cid, $data, $expire, $tags);
+    $pipe = $this->client->pipeline();
+    $pipe->hmset($key, $entry);
+    $pipe->expire($key, $ttl);
+    $pipe->execute();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteMultiple(array $cids) {
+    if (!empty($cids)) {
+      $keys = array_map([$this, 'getKey'], $cids);
+      $this->client->del($keys);
+    }
+  }
+
+
+}

sites/all/modules/contrib/dev/redis/src/Cache/RedisCacheTagsChecksum.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Drupal\redis\Cache;
+
+use Drupal\Core\Cache\CacheTagsChecksumInterface;
+use Drupal\Core\Cache\CacheTagsInvalidatorInterface;
+use Drupal\redis\ClientFactory;
+use Drupal\redis\RedisPrefixTrait;
+
+/**
+ * Cache tags invalidations checksum implementation that uses redis.
+ */
+class RedisCacheTagsChecksum implements CacheTagsChecksumInterface, CacheTagsInvalidatorInterface {
+
+  use RedisPrefixTrait;
+
+  /**
+   * Contains already loaded cache invalidations from the database.
+   *
+   * @var array
+   */
+  protected $tagCache = [];
+
+  /**
+   * A list of tags that have already been invalidated in this request.
+   *
+   * Used to prevent the invalidation of the same cache tag multiple times.
+   *
+   * @var array
+   */
+  protected $invalidatedTags = [];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $client;
+
+  /**
+   * @var string
+   */
+  protected $clientType;
+
+  /**
+   * Creates a PHpRedis cache backend.
+   */
+  public function __construct(ClientFactory $factory) {
+    $this->client = $factory->getClient();
+    $this->clientType = $factory->getClientName();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateTags(array $tags) {
+    $keys_to_increment = [];
+    foreach ($tags as $tag) {
+      // Only invalidate tags once per request unless they are written again.
+      if (isset($this->invalidatedTags[$tag])) {
+        continue;
+      }
+      $this->invalidatedTags[$tag] = TRUE;
+      unset($this->tagCache[$tag]);
+      $keys_to_increment[] = $this->getTagKey($tag);
+    }
+    if ($keys_to_increment) {
+
+      // We want to differentiate between PhpRedis and Redis clients.
+      if ($this->clientType === 'PhpRedis') {
+        $multi = $this->client->multi(\Redis::PIPELINE);
+        foreach ($keys_to_increment as $key) {
+          $multi->incr($key);
+        }
+        $multi->exec();
+      }
+      elseif ($this->clientType === 'Predis') {
+
+        $pipe = $this->client->pipeline();
+        foreach ($keys_to_increment as $key) {
+          $pipe->incr($key);
+        }
+        $pipe->execute();
+      }
+    }
+
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCurrentChecksum(array $tags) {
+    // Remove tags that were already invalidated during this request from the
+    // static caches so that another invalidation can occur later in the same
+    // request. Without that, written cache items would not be invalidated
+    // correctly.
+    foreach ($tags as $tag) {
+      unset($this->invalidatedTags[$tag]);
+    }
+    return $this->calculateChecksum($tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isValid($checksum, array $tags) {
+    return $checksum == $this->calculateChecksum($tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateChecksum(array $tags) {
+    $checksum = 0;
+
+    $fetch = array_values(array_diff($tags, array_keys($this->tagCache)));
+    if ($fetch) {
+      $keys = array_map([$this, 'getTagKey'], $fetch);
+      foreach ($this->client->mget($keys) as $index => $invalidations) {
+        $this->tagCache[$fetch[$index]] = $invalidations ?: 0;
+      }
+    }
+
+    foreach ($tags as $tag) {
+      $checksum += $this->tagCache[$tag];
+    }
+
+    return $checksum;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function reset() {
+    $this->tagCache = [];
+    $this->invalidatedTags = [];
+  }
+
+  /**
+   * Return the key for the given cache tag.
+   *
+   * @param string $tag
+   *   The cache tag.
+   *
+   * @return string
+   *   The prefixed cache tag.
+   */
+  protected function getTagKey($tag) {
+    return $this->getPrefix() . ':cachetags:' . $tag;
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Client/PhpRedis.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Drupal\redis\Client;
+
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\Core\Site\Settings;
+use Drupal\redis\ClientInterface;
+
+/**
+ * PhpRedis client specific implementation.
+ */
+class PhpRedis implements ClientInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getClient($host = NULL, $port = NULL, $base = NULL, $password = NULL) {
+    $client = new \Redis();
+
+    // Sentinel mode, get the real master.
+    if (is_array($host)) {
+      $ip_host = $this->askForMaster($client, $host, $password);
+      if (is_array($ip_host)) {
+        list($host, $port) = $ip_host;
+      }
+    }
+
+    $client->connect($host, $port);
+
+    if (isset($password)) {
+      $client->auth($password);
+    }
+
+    if (isset($base)) {
+      $client->select($base);
+    }
+
+    // Do not allow PhpRedis serialize itself data, we are going to do it
+    // ourself. This will ensure less memory footprint on Redis size when
+    // we will attempt to store small values.
+    $client->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_NONE);
+
+    return $client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getName() {
+    return 'PhpRedis';
+  }
+
+  /**
+   * Connect to sentinels to get Redis master instance.
+   *
+   * Just asking one sentinels after another until given the master location.
+   * More info about this mode at https://redis.io/topics/sentinel.
+   *
+   * @param \Redis $client
+   *   The PhpRedis client.
+   * @param array $sentinels
+   *   An array of the sentinels' ip:port.
+   * @param string $password
+   *   An optional Sentinels' password.
+   *
+   * @return mixed
+   *   An array with ip & port of the Master instance or NULL.
+   */
+  protected function askForMaster(\Redis $client, array $sentinels = [], $password = NULL) {
+
+    $ip_port = NULL;
+    $settings = Settings::get('redis.connection', []);
+    $settings += ['instance' => NULL];
+
+    if ($settings['instance']) {
+      foreach ($sentinels as $sentinel) {
+        list($host, $port) = explode(':', $sentinel);
+        // 0.5s timeout.
+        $client->connect($host, $port, 0.5);
+
+        if (isset($password)) {
+          $client->auth($password);
+        }
+
+        if ($client->isConnected()) {
+          $ip_port = $client->rawcommand('SENTINEL', 'get-master-addr-by-name', $settings['instance']);
+          if ($ip_port) {
+            break;
+          }
+        }
+        $client->close();
+      }
+    }
+    return $ip_port;
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Client/Predis.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Drupal\redis\Client;
+
+use Drupal\redis\ClientInterface;
+use Predis\Client;
+
+
+/**
+ * Predis client specific implementation.
+ */
+class Predis implements ClientInterface {
+
+  public function getClient($host = NULL, $port = NULL, $base = NULL, $password = NULL, $replicationHosts = NULL) {
+    $connectionInfo = [
+      'password' => $password,
+      'host'     => $host,
+      'port'     => $port,
+      'database' => $base
+    ];
+
+    foreach ($connectionInfo as $key => $value) {
+      if (!isset($value)) {
+        unset($connectionInfo[$key]);
+      }
+    }
+
+    // I'm not sure why but the error handler is driven crazy if timezone
+    // is not set at this point.
+    // Hopefully Drupal will restore the right one this once the current
+    // account has logged in.
+    date_default_timezone_set(@date_default_timezone_get());
+
+    // If we are passed in an array of $replicationHosts, we should attempt a clustered client connection.
+    if ($replicationHosts !== NULL) {
+      $parameters = [];
+
+      foreach ($replicationHosts as $replicationHost) {
+        // Configure master.
+        if ($replicationHost['role'] === 'primary') {
+          $parameters[] = 'tcp://' . $replicationHost['host'] . ':' . $replicationHost['port'] . '?alias=master';
+        }
+        else {
+          $parameters[] = 'tcp://' . $replicationHost['host'] . ':' . $replicationHost['port'];
+        }
+      }
+
+      $options = ['replication' => true];
+      $client = new Client($parameters, $options);
+    }
+    else {
+      $client = new Client($connectionInfo);
+    }
+    return $client;
+
+  }
+
+  public function getName() {
+    return 'Predis';
+  }
+}

sites/all/modules/contrib/dev/redis/src/ClientFactory.php

@@ -0,0 +1,215 @@
+<?php
+
+namespace Drupal\redis;
+use Drupal\Core\Site\Settings;
+
+/**
+ * Common code and client singleton, for all Redis clients.
+ */
+class ClientFactory {
+  /**
+   * Redis default host.
+   */
+  const REDIS_DEFAULT_HOST = "127.0.0.1";
+
+  /**
+   * Redis default port.
+   */
+  const REDIS_DEFAULT_PORT = 6379;
+
+  /**
+   * Redis default database: will select none (Database 0).
+   */
+  const REDIS_DEFAULT_BASE = NULL;
+
+  /**
+   * Redis default password: will not authenticate.
+   */
+  const REDIS_DEFAULT_PASSWORD = NULL;
+
+  /**
+   * Cache implementation namespace.
+   */
+  const REDIS_IMPL_CACHE = '\\Drupal\\redis\\Cache\\';
+
+  /**
+   * Lock implementation namespace.
+   */
+  const REDIS_IMPL_LOCK = '\\Drupal\\redis\\Lock\\';
+
+  /**
+   * Lock implementation namespace.
+   */
+  const REDIS_IMPL_FLOOD = '\\Drupal\\redis\\Flood\\';
+
+  /**
+   * Persistent Lock implementation namespace.
+   */
+  const REDIS_IMPL_PERSISTENT_LOCK = '\\Drupal\\redis\\PersistentLock\\';
+
+  /**
+   * Client implementation namespace.
+   */
+  const REDIS_IMPL_CLIENT = '\\Drupal\\redis\\Client\\';
+
+  /**
+   * Queue implementation namespace.
+   */
+  const REDIS_IMPL_QUEUE = '\\Drupal\\redis\\Queue\\';
+
+  /**
+   * Reliable queue implementation namespace.
+   */
+  const REDIS_IMPL_RELIABLE_QUEUE = '\\Drupal\\redis\\Queue\\Reliable';
+
+  /**
+   * @var \Drupal\redis\ClientInterface
+   */
+  protected static $_clientInterface;
+
+  /**
+   * @var mixed
+   */
+  protected static $_client;
+
+  public static function hasClient() {
+    return isset(self::$_client);
+  }
+
+  /**
+   * Set client proxy.
+   */
+  public static function setClient(ClientInterface $interface) {
+    if (isset(self::$_client)) {
+      throw new \Exception("Once Redis client is connected, you cannot change client proxy instance.");
+    }
+
+    self::$_clientInterface = $interface;
+  }
+
+  /**
+   * Lazy instanciate client proxy depending on the actual configuration.
+   *
+   * If you are using a lock or cache backend using one of the Redis client
+   * implementations, this will be overridden at early bootstrap phase and
+   * configuration will be ignored.
+   *
+   * @return ClientInterface
+   */
+  public static function getClientInterface()
+  {
+    if (!isset(self::$_clientInterface))
+    {
+      $settings = Settings::get('redis.connection', []);
+      if (!empty($settings['interface']))
+      {
+        $className = self::getClass(self::REDIS_IMPL_CLIENT, $settings['interface']);
+        self::$_clientInterface = new $className();
+      }
+      elseif (class_exists('Predis\Client'))
+      {
+        // Transparent and abitrary preference for Predis library.
+        $className = self::getClass(self::REDIS_IMPL_CLIENT, 'Predis');
+        self::$_clientInterface = new $className();
+      }
+      elseif (class_exists('Redis'))
+      {
+        // Fallback on PhpRedis if available.
+        $className = self::getClass(self::REDIS_IMPL_CLIENT, 'PhpRedis');
+        self::$_clientInterface = new $className();
+      }
+      else
+      {
+        if (!isset(self::$_clientInterface))
+        {
+          throw new \Exception("No client interface set.");
+        }
+      }
+    }
+
+    return self::$_clientInterface;
+  }
+
+  /**
+   * Get underlaying library name.
+   *
+   * @return string
+   */
+  public static function getClientName() {
+    return self::getClientInterface()->getName();
+  }
+
+  /**
+   * Get client singleton.
+   */
+  public static function getClient() {
+    if (!isset(self::$_client)) {
+      $settings = Settings::get('redis.connection', []);
+      $settings += [
+        'host' => self::REDIS_DEFAULT_HOST,
+        'port' => self::REDIS_DEFAULT_PORT,
+        'base' => self::REDIS_DEFAULT_BASE,
+        'password' => self::REDIS_DEFAULT_PASSWORD,
+      ];
+
+      // If using replication, lets create the client appropriately.
+      if (isset($settings['replication']) && $settings['replication'] === TRUE) {
+        foreach ($settings['replication.host'] as $key => $replicationHost) {
+          if (!isset($replicationHost['port'])) {
+            $settings['replication.host'][$key]['port'] = self::REDIS_DEFAULT_PORT;
+          }
+        }
+
+        self::$_client = self::getClientInterface()->getClient(
+          $settings['host'],
+          $settings['port'],
+          $settings['base'],
+          $settings['password'],
+          $settings['replication.host']);
+      }
+      else {
+        self::$_client = self::getClientInterface()->getClient(
+          $settings['host'],
+          $settings['port'],
+          $settings['base'],
+          $settings['password']);
+      }
+    }
+
+    return self::$_client;
+  }
+
+  /**
+   * Get specific class implementing the current client usage for the specific
+   * asked core subsystem.
+   *
+   * @param string $system
+   *   One of the ClientFactory::IMPL_* constant.
+   * @param string $clientName
+   *   Client name, if fixed.
+   *
+   * @return string
+   *   Class name, if found.
+   *
+   * @throws \Exception
+   *   If not found.
+   */
+  public static function getClass($system, $clientName = NULL) {
+    $className = $system . ($clientName ?: self::getClientName());
+
+    if (!class_exists($className)) {
+      throw new \Exception($className . " does not exists");
+    }
+
+    return $className;
+  }
+
+  /**
+   * For unit testing only reset internals.
+   */
+  static public function reset() {
+    self::$_clientInterface = null;
+    self::$_client = null;
+  }
+}
+

sites/all/modules/contrib/dev/redis/src/ClientInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\redis;
+
+/**
+ * Client proxy, client handling class tied to the bare mininum.
+ */
+interface ClientInterface {
+  /**
+   * Get the connected client instance.
+   *
+   * @return mixed
+   *   Real client depends from the library behind.
+   */
+  public function getClient($host = NULL, $port = NULL, $base = NULL);
+
+  /**
+   * Get underlaying library name used.
+   *
+   * This can be useful for contribution code that may work with only some of
+   * the provided clients.
+   *
+   * @return string
+   */
+  public function getName();
+}

sites/all/modules/contrib/dev/redis/src/Flood/FloodFactory.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Drupal\redis\Flood;
+
+use Drupal\redis\ClientFactory;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+/**
+ * Flood backend singleton handling.
+ */
+class FloodFactory {
+
+  /**
+   * @var \Drupal\redis\ClientInterface
+   */
+  protected $clientFactory;
+
+  /**
+   * The request stack.
+   *
+   * @var \Symfony\Component\HttpFoundation\RequestStack
+   */
+  protected $requestStack;
+
+  /**
+   * Construct the PhpRedis flood backend factory.
+   *
+   * @param \Drupal\redis\ClientFactory $client_factory
+   *   The database connection which will be used to store the flood event
+   *   information.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack used to retrieve the current request.
+   */
+  public function __construct(ClientFactory $client_factory, RequestStack $request_stack) {
+    $this->clientFactory = $client_factory;
+    $this->requestStack = $request_stack;
+  }
+
+  /**
+   * Get actual flood backend.
+   *
+   * @return \Drupal\Core\Flood\FloodInterface
+   *   Return flood instance.
+   */
+  public function get() {
+    $class_name = $this->clientFactory->getClass(ClientFactory::REDIS_IMPL_FLOOD);
+    return new $class_name($this->clientFactory, $this->requestStack);
+  }
+}

sites/all/modules/contrib/dev/redis/src/Flood/PhpRedis.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Drupal\redis\Flood;
+
+use Drupal\Core\Flood\FloodInterface;
+use Drupal\redis\ClientFactory;
+use Drupal\redis\RedisPrefixTrait;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+/**
+ * Defines the database flood backend. This is the default Drupal backend.
+ */
+class PhpRedis implements FloodInterface {
+
+  use RedisPrefixTrait;
+
+  /**
+   * @var \Redis
+   */
+  protected $client;
+
+  /**
+   * The request stack.
+   *
+   * @var \Symfony\Component\HttpFoundation\RequestStack
+   */
+  protected $requestStack;
+
+  /**
+   * Construct the PhpRedis flood backend.
+   *
+   * @param \Drupal\redis\ClientFactory $client_factory
+   *   The database connection which will be used to store the flood event
+   *   information.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack used to retrieve the current request.
+   */
+  public function __construct(ClientFactory $client_factory, RequestStack $request_stack) {
+    $this->client = $client_factory->getClient();
+    $this->requestStack = $request_stack;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function register($name, $window = 3600, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+
+    // Add a key for the event to the sorted set, the score is timestamp, so we
+    // can count them easily.
+    $this->client->zAdd($key, $_SERVER['REQUEST_TIME'] + $window, microtime(TRUE));
+    // Set or update the expiration for the sorted set, it will be removed if
+    // the newest entry expired.
+    $this->client->expire($key, $_SERVER['REQUEST_TIME'] + $window);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function clear($name, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+    $this->client->del($key);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isAllowed($name, $threshold, $window = 3600, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+
+    // Count the in the last $window seconds.
+    $number = $this->client->zCount($key, $_SERVER['REQUEST_TIME'], 'inf');
+    return ($number < $threshold);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function garbageCollection() {
+    // No garbage collection necessary.
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Flood/Predis.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Drupal\redis\Flood;
+
+use Drupal\Core\Flood\FloodInterface;
+use Drupal\redis\ClientFactory;
+use Drupal\redis\RedisPrefixTrait;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+/**
+ * Defines the database flood backend. This is the default Drupal backend.
+ */
+class Predis implements FloodInterface {
+
+  use RedisPrefixTrait;
+
+  /**
+   * @var \Predis\Client
+   */
+  protected $client;
+
+  /**
+   * The request stack.
+   *
+   * @var \Symfony\Component\HttpFoundation\RequestStack
+   */
+  protected $requestStack;
+
+  /**
+   * Construct the PhpRedis flood backend.
+   *
+   * @param \Drupal\redis\ClientFactory $client_factory
+   *   The database connection which will be used to store the flood event
+   *   information.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack used to retrieve the current request.
+   */
+  public function __construct(ClientFactory $client_factory, RequestStack $request_stack) {
+    $this->client = $client_factory->getClient();
+    $this->requestStack = $request_stack;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function register($name, $window = 3600, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+
+    // Add a key for the event to the sorted set, the score is timestamp, so we
+    // can count them easily.
+    $this->client->zAdd($key, $_SERVER['REQUEST_TIME'] + $window, microtime(TRUE));
+    // Set or update the expiration for the sorted set, it will be removed if
+    // the newest entry expired.
+    $this->client->expire($key, $_SERVER['REQUEST_TIME'] + $window);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function clear($name, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+    $this->client->del($key);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isAllowed($name, $threshold, $window = 3600, $identifier = NULL) {
+    if (!isset($identifier)) {
+      $identifier = $this->requestStack->getCurrentRequest()->getClientIp();
+    }
+
+    $key = $this->getPrefix() . ':flood:' . $name . ':' . $identifier;
+
+    // Count the in the last $window seconds.
+    $number = $this->client->zCount($key, $_SERVER['REQUEST_TIME'], 'inf');
+    return ($number < $threshold);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function garbageCollection() {
+    // No garbage collection necessary.
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Lock/LockFactory.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\redis\Lock;
+
+use Drupal\redis\ClientFactory;
+
+/**
+ * Lock backend singleton handling.
+ */
+class LockFactory {
+
+  /**
+   * @var \Drupal\redis\ClientInterface
+   */
+  protected $clientFactory;
+
+  /**
+   * Creates a redis LockFactory.
+   */
+  public function __construct(ClientFactory $client_factory) {
+    $this->clientFactory = $client_factory;
+  }
+
+  /**
+   * Get actual lock backend.
+   *
+   * @param bool $persistent
+   *   (optional) Whether to return a persistent lock implementation or not.
+   *
+   * @return \Drupal\Core\Lock\LockBackendInterface
+   *   Return lock backend instance.
+   */
+  public function get($persistent = FALSE) {
+    $class_name = $this->clientFactory->getClass($persistent ? ClientFactory::REDIS_IMPL_PERSISTENT_LOCK : ClientFactory::REDIS_IMPL_LOCK);
+    return new $class_name($this->clientFactory);
+  }
+}

sites/all/modules/contrib/dev/redis/src/Lock/PhpRedis.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\redis\Lock;
+
+use Drupal\Core\Lock\LockBackendAbstract;
+use Drupal\redis\ClientFactory;
+use Drupal\redis\RedisPrefixTrait;
+
+/**
+ * Predis lock backend implementation.
+ */
+class PhpRedis extends LockBackendAbstract {
+
+  use RedisPrefixTrait;
+
+  /**
+   * @var \Redis
+   */
+  protected $client;
+
+  /**
+   * Creates a PHpRedis cache backend.
+   */
+  public function __construct(ClientFactory $factory) {
+    $this->client = $factory->getClient();
+    // __destruct() is causing problems with garbage collections, register a
+    // shutdown function instead.
+    drupal_register_shutdown_function([$this, 'releaseAll']);
+  }
+
+  /**
+   * Generate a redis key name for the current lock name.
+   *
+   * @param string $name
+   *   Lock name.
+   *
+   * @return string
+   *   The redis key for the given lock.
+   */
+  protected function getKey($name) {
+    return $this->getPrefix() . ':lock:' . $name;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function acquire($name, $timeout = 30.0) {
+    $key    = $this->getKey($name);
+    $id     = $this->getLockId();
+
+    // Insure that the timeout is at least 1 ms.
+    $timeout = max($timeout, 0.001);
+
+    // If we already have the lock, check for his owner and attempt a new EXPIRE
+    // command on it.
+    if (isset($this->locks[$name])) {
+
+      // Create a new transaction, for atomicity.
+      $this->client->watch($key);
+
+      // Global tells us we are the owner, but in real life it could have expired
+      // and another process could have taken it, check that.
+      if ($this->client->get($key) != $id) {
+        // Explicit UNWATCH we are not going to run the MULTI/EXEC block.
+        $this->client->unwatch();
+        unset($this->locks[$name]);
+        return FALSE;
+      }
+
+      $result = $this->client->multi()
+        ->psetex($key, (int) ($timeout * 1000), $id)
+        ->exec();
+
+      // If the set failed, someone else wrote the key, we failed to acquire
+      // the lock.
+      if (FALSE === $result) {
+        unset($this->locks[$name]);
+        // Explicit transaction release which also frees the WATCH'ed key.
+        $this->client->discard();
+        return FALSE;
+      }
+
+      return ($this->locks[$name] = TRUE);
+    }
+    else {
+      // Use a SET with microsecond expiration and the NX flag, which will only
+      // succeed if the key does not exist yet.
+      $result = $this->client->set($key, $id, ['nx', 'px' => (int) ($timeout * 1000)]);
+
+      // If the result is FALSE, we failed to acquire the lock.
+      if (FALSE === $result) {
+        return FALSE;
+      }
+
+      // Register the lock.
+      return ($this->locks[$name] = TRUE);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function lockMayBeAvailable($name) {
+    $key    = $this->getKey($name);
+    $value = $this->client->get($key);
+
+    // In Drupal 7, this method treated the lock as available if the ID did
+    // match. The database backend and test expects it to return FALSE in that
+    // case, updated accordingly.
+    return FALSE === $value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function release($name) {
+    $key    = $this->getKey($name);
+    $id     = $this->getLockId();
+
+    unset($this->locks[$name]);
+
+    // Ensure the lock deletion is an atomic transaction. If another thread
+    // manages to removes all lock, we can not alter it anymore else we will
+    // release the lock for the other thread and cause race conditions.
+    $this->client->watch($key);
+
+    if ($this->client->get($key) == $id) {
+      $this->client->multi();
+      $this->client->delete($key);
+      $this->client->exec();
+    }
+    else {
+      $this->client->unwatch();
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseAll($lock_id = NULL) {
+    // We can afford to deal with a slow algorithm here, this should not happen
+    // on normal run because we should have removed manually all our locks.
+    foreach ($this->locks as $name => $foo) {
+      $this->release($name);
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/src/Lock/Predis.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace Drupal\redis\Lock;
+
+use Drupal\Core\Lock\LockBackendAbstract;
+use Drupal\redis\ClientFactory;
+use Drupal\redis\RedisPrefixTrait;
+
+/**
+ * Predis lock backend implementation.
+ */
+class Predis extends LockBackendAbstract {
+
+  use RedisPrefixTrait;
+
+  /**
+   * @var \Predis\Client
+   */
+  protected $client;
+
+  /**
+   * Creates a PHpRedis cache backend.
+   */
+  public function __construct(ClientFactory $factory) {
+    $this->client = $factory->getClient();
+    // __destruct() is causing problems with garbage collections, register a
+    // shutdown function instead.
+    drupal_register_shutdown_function([$this, 'releaseAll']);
+  }
+
+  /**
+   * Generate a redis key name for the current lock name.
+   *
+   * @param string $name
+   *   Lock name.
+   *
+   * @return string
+   *   The redis key for the given lock.
+   */
+  protected function getKey($name) {
+    return $this->getPrefix() . ':lock:' . $name;
+  }
+
+  public function acquire($name, $timeout = 30.0) {
+    $key    = $this->getKey($name);
+    $id     = $this->getLockId();
+
+    // Insure that the timeout is at least 1 ms.
+    $timeout = max($timeout, 0.001);
+
+    // If we already have the lock, check for his owner and attempt a new EXPIRE
+    // command on it.
+    if (isset($this->locks[$name])) {
+
+      // Create a new transaction, for atomicity.
+      $this->client->watch($key);
+
+      // Global tells us we are the owner, but in real life it could have expired
+      // and another process could have taken it, check that.
+      if ($this->client->get($key) != $id) {
+        // Explicit UNWATCH we are not going to run the MULTI/EXEC block.
+        $this->client->unwatch();
+        unset($this->locks[$name]);
+        return FALSE;
+      }
+
+      $result = $this->client->pipeline()
+        ->psetex($key, (int) ($timeout * 1000), $id)
+        ->exec();
+
+      // If the set failed, someone else wrote the key, we failed to acquire
+      // the lock.
+      if (FALSE === $result) {
+        unset($this->locks[$name]);
+        // Explicit transaction release which also frees the WATCH'ed key.
+        $this->client->discard();
+        return FALSE;
+      }
+
+      return ($this->locks[$name] = TRUE);
+    }
+    else {
+      // Use a SET with microsecond expiration and the NX flag, which will only
+      // succeed if the key does not exist yet.
+      $result = $this->client->set($key, $id, 'nx', 'px', (int) ($timeout * 1000));
+
+      // If the result is FALSE, we failed to acquire the lock.
+      if (FALSE === $result) {
+        return FALSE;
+      }
+
+      // Register the lock.
+      return ($this->locks[$name] = TRUE);
+    }
+  }
+
+  public function lockMayBeAvailable($name) {
+    $key = $this->getKey($name);
+    $value = $this->client->get($key);
+
+    // In Drupal 7, this method treated the lock as available if the ID did
+    // match. The database backend and test expects it to return FALSE in that
+    // case, updated accordingly.
+    return FALSE === $value;
+  }
+
+  public function release($name) {
+    $key    = $this->getKey($name);
+    $id     = $this->getLockId();
+
+    unset($this->locks[$name]);
+
+    // Ensure the lock deletion is an atomic transaction. If another thread
+    // manages to removes all lock, we can not alter it anymore else we will
+    // release the lock for the other thread and cause race conditions.
+    $this->client->watch($key);
+
+    if ($this->client->get($key) == $id) {
+      $pipe = $this->client->pipeline();
+      $pipe->del([$key]);
+      $pipe->execute();
+    }
+    else {
+      $this->client->unwatch();
+    }
+  }
+
+  public function releaseAll($lock_id = NULL) {
+    // We can afford to deal with a slow algorithm here, this should not happen
+    // on normal run because we should have removed manually all our locks.
+    foreach ($this->locks as $name => $foo) {
+      $this->release($name);
+    }
+  }
+}
+

sites/all/modules/contrib/dev/redis/src/PersistentLock/PhpRedis.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\redis\PersistentLock;
+
+use Drupal\redis\ClientFactory;
+
+/**
+ * PHpRedis persistent lock backend
+ */
+class PhpRedis extends \Drupal\redis\Lock\PhpRedis {
+
+  /**
+   * Creates a PHpRedis persistent lock backend.
+   */
+  public function __construct(ClientFactory $factory) {
+    // Do not call the parent constructor to avoid registering a shutdown
+    // function that releases all the locks at the end of a request.
+    $this->client = $factory->getClient();
+    // Set the lockId to a fixed string to make the lock ID the same across
+    // multiple requests. The lock ID is used as a page token to relate all the
+    // locks set during a request to each other.
+    // @see \Drupal\Core\Lock\LockBackendInterface::getLockId()
+    $this->lockId = 'persistent';
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Queue/PhpRedis.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+/**
+ * Redis queue implementation using PhpRedis extension backend.
+ *
+ * @ingroup queue
+ */
+class PhpRedis extends QueueBase {
+
+  /**
+   * The Redis connection.
+   *
+   * @var \Redis $client
+   */
+  protected $client;
+
+  /**
+   * Constructs a \Drupal\redis\Queue\PhpRedis object.
+   *
+   * @param string $name
+   *   The name of the queue.
+   * @param array $settings
+   *   Array of Redis-related settings for this queue.
+   * @param \Redis $client
+   *   The PhpRedis client.
+   */
+  public function __construct($name, array $settings, \Redis $client) {
+    parent::__construct($name, $settings);
+    $this->client = $client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createItem($data) {
+    $record = new \stdClass();
+    $record->data = $data;
+    $record->qid = $this->incrementId();
+    // We cannot rely on REQUEST_TIME because many items might be created
+    // by a single request which takes longer than 1 second.
+    $record->timestamp = time();
+
+    if (!$this->client->hsetnx($this->availableItems, $record->qid, serialize($record))) {
+      return FALSE;
+    }
+
+    $start_len = $this->client->lLen($this->availableListKey);
+    if ($start_len < $this->client->lpush($this->availableListKey, $record->qid)) {
+      return $record->qid;
+    }
+
+    return FALSE;
+  }
+
+  /**
+   * Gets next serial ID for Redis queue items.
+   *
+   * @return int
+   *   Next serial ID for Redis queue item.
+   */
+  protected function incrementId() {
+    return $this->client->incr($this->incrementCounterKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function numberOfItems() {
+    return $this->client->lLen($this->availableListKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function claimItem($lease_time = 30) {
+    // Is it OK to do garbage collection here (we need to loop list of claimed
+    // items)?
+    $this->garbageCollection();
+    $item = FALSE;
+
+    if ($this->reserveTimeout !== NULL) {
+      // A blocking version of claimItem to be used with long-running queue workers.
+      $qid = $this->client->brpoplpush($this->availableListKey, $this->claimedListKey, $this->reserveTimeout);
+    }
+    else {
+      $qid = $this->client->rpoplpush($this->availableListKey, $this->claimedListKey);
+    }
+
+    if ($qid) {
+      $job = $this->client->hget($this->availableItems, $qid);
+      if ($job) {
+        $item = unserialize($job);
+        $this->client->setex($this->leasedKeyPrefix . $item->qid, $lease_time, '1');
+      }
+    }
+
+    return $item;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseItem($item) {
+    $this->client->lrem($this->claimedListKey, $item->qid, -1);
+    $this->client->lpush($this->availableListKey, $item->qid);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteItem($item) {
+    $this->client->lrem($this->claimedListKey, $item->qid, -1);
+    $this->client->hdel($this->availableItems, $item->qid);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteQueue() {
+    $keys_to_remove = [
+      $this->claimedListKey,
+      $this->availableListKey,
+      $this->availableItems,
+      $this->incrementCounterKey
+    ];
+
+    foreach ($this->client->keys($this->leasedKeyPrefix . '*') as $key) {
+      $keys_to_remove[] = $key;
+    }
+
+    $this->client->del($keys_to_remove);
+  }
+
+  /**
+   * Automatically release items, that have been claimed and exceeded lease time.
+   */
+  protected function garbageCollection() {
+    foreach ($this->client->lrange($this->claimedListKey, 0, -1) as $qid) {
+      if (!$this->client->exists($this->leasedKeyPrefix . $qid)) {
+        // The lease expired for this ID.
+        $this->client->lrem($this->claimedListKey, $qid, -1);
+        $this->client->lpush($this->availableListKey, $qid);
+      }
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/src/Queue/Predis.php

@@ -0,0 +1,152 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+/**
+ * Redis queue implementation using Predis library backend.
+ *
+ * @ingroup queue
+ */
+class Predis extends QueueBase {
+
+  /**
+   * The Redis connection.
+   *
+   * @var \Predis\Client $client
+   */
+  protected $client;
+
+  /**
+   * Constructs a \Drupal\redis\Queue\Predis object.
+   *
+   * @param string $name
+   *   The name of the queue.
+   * @param array $settings
+   *   Array of Redis-related settings for this queue.
+   * @param \Predis\Client $client
+   *   The Predis client.
+   */
+  public function __construct($name, array $settings, \Predis\Client $client) {
+    parent::__construct($name, $settings);
+    $this->client = $client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createItem($data) {
+    // TODO: Fixme
+    $record = new \stdClass();
+    $record->data = $data;
+    $record->qid = $this->incrementId();
+    // We cannot rely on REQUEST_TIME because many items might be created
+    // by a single request which takes longer than 1 second.
+    $record->timestamp = time();
+
+    if (!$this->client->hsetnx($this->availableItems, $record->qid, serialize($record))) {
+      return FALSE;
+    }
+
+    $start_len = $this->client->lLen($this->availableListKey);
+    if ($start_len < $this->client->lpush($this->availableListKey, $record->qid)) {
+      return $record->qid;
+    }
+  }
+
+  /**
+   * Gets next serial ID for Redis queue items.
+   *
+   * @return int
+   *   Next serial ID for Redis queue item.
+   */
+  protected function incrementId() {
+    // TODO: Fixme
+    return $this->client->incr($this->incrementCounterKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function numberOfItems() {
+    // TODO: Fixme
+    return $this->client->lLen($this->availableListKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function claimItem($lease_time = 30) {
+    // Is it OK to do garbage collection here (we need to loop list of claimed
+    // items)?
+    $this->garbageCollection();
+    $item = FALSE;
+
+    if ($this->reserveTimeout !== NULL) {
+      // A blocking version of claimItem to be used with long-running queue workers.
+      $qid = $this->client->brpoplpush($this->availableListKey, $this->claimedListKey, $this->reserveTimeout);
+    }
+    else {
+      $qid = $this->client->rpoplpush($this->availableListKey, $this->claimedListKey);
+    }
+
+    if ($qid) {
+      $job = $this->client->hget($this->availableItems, $qid);
+      if ($job) {
+        $item = unserialize($job);
+        $this->client->setex($this->leasedKeyPrefix . $item->qid, $lease_time, '1');
+      }
+    }
+
+    return $item;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseItem($item) {
+    // TODO: Fixme
+    $this->client->lrem($this->claimedListKey, $item->qid, -1);
+    $this->client->lpush($this->availableListKey, $item->qid);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteItem($item) {
+    // TODO: Fixme
+    $this->client->lrem($this->claimedListKey, $item->qid, -1);
+    $this->client->hdel($this->availableItems, $item->qid);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteQueue() {
+    // TODO: Fixme
+    $keys_to_remove = [
+      $this->claimedListKey,
+      $this->availableListKey,
+      $this->availableItems,
+      $this->incrementCounterKey
+    ];
+
+    foreach ($this->client->keys($this->leasedKeyPrefix . '*') as $key) {
+      $keys_to_remove[] = $key;
+    }
+
+    $this->client->del($keys_to_remove);
+  }
+
+  /**
+   * Automatically release items, that have been claimed and exceeded lease time.
+   */
+  protected function garbageCollection() {
+    foreach ($this->client->lrange($this->claimedListKey, 0, -1) as $qid) {
+      if (!$this->client->exists($this->leasedKeyPrefix . $qid)) {
+        // The lease expired for this ID.
+        $this->client->lrem($this->claimedListKey, $qid, -1);
+        $this->client->lpush($this->availableListKey, $qid);
+      }
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/src/Queue/QueueBase.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+use Drupal\Core\Queue\QueueInterface;
+
+/**
+ * Redis queue implementation.
+ *
+ * @ingroup queue
+ */
+abstract class QueueBase implements QueueInterface {
+
+  /**
+   * Prefix used with all keys.
+   */
+  const KEY_PREFIX = 'drupal:queue:';
+
+  /**
+   * The name of the queue this instance is working with.
+   *
+   * @var string
+   */
+  protected $name;
+
+  /**
+   * Key for list of available items.
+   *
+   * @var string
+   */
+  protected $availableListKey;
+
+  /**
+   * Key for list of claimed items.
+   *
+   * @var string
+   */
+  protected $claimedListKey;
+
+  /**
+   * Key prefix for items that are used to track expiration of leased items.
+   *
+   * @var string
+   */
+  protected $leasedKeyPrefix;
+
+  /**
+   * Key of increment counter key.
+   *
+   * @var string
+   */
+  protected $incrementCounterKey;
+
+  /**
+   * Key for hash table of available queue items.
+   *
+   * @var string
+   */
+  protected $availableItems;
+
+  /**
+   * Reserve timeout for blocking item claim.
+   *
+   * This will be set to number of seconds to wait for an item to be claimed.
+   * Non-blocking approach will be used when set to NULL.
+   *
+   * @var int|null
+   */
+  protected $reserveTimeout;
+
+  /**
+   * Constructs a \Drupal\Core\Queue\DatabaseQueue object.
+   *
+   * @param string $name
+   *   The name of the queue.
+   * @param array $settings
+   *   Array of Redis-related settings for this queue.
+   */
+  public function __construct($name, array $settings) {
+    $this->name = $name;
+    $this->reserveTimeout = $settings['reserve_timeout'];
+    $this->availableListKey = static::KEY_PREFIX . $name . ':avail';
+    $this->availableItems = static::KEY_PREFIX . $name . ':items';
+    $this->claimedListKey = static::KEY_PREFIX . $name . ':claimed';
+    $this->leasedKeyPrefix = static::KEY_PREFIX . $name . ':lease:';
+    $this->incrementCounterKey = static::KEY_PREFIX . $name . ':counter';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createQueue() {
+    // Nothing to do here.
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Queue/QueueRedisFactory.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+use Drupal\Core\Site\Settings;
+use Drupal\redis\ClientFactory;
+
+/**
+ * Defines the queue factory for the Redis backend.
+ */
+class QueueRedisFactory {
+
+  /**
+   * Queue implementation class namespace prefix.
+   */
+  const CLASS_NAMESPACE = ClientFactory::REDIS_IMPL_QUEUE;
+
+  /**
+   * @var \Drupal\redis\ClientFactory
+   */
+  protected $clientFactory;
+
+  /**
+   * The settings array.
+   *
+   * @var \Drupal\Core\Site\Settings
+   */
+  protected $settings;
+
+  /**
+   * Constructs this factory object.
+   *
+   * @param \Drupal\Core\Database\Connection $connection
+   *   The Connection object containing the key-value tables.
+   */
+  public function __construct(ClientFactory $client_factory, Settings $settings) {
+    $this->clientFactory = $client_factory;
+    $this->settings = $settings;
+  }
+
+  /**
+   * Constructs a new queue object for a given name.
+   *
+   * @param string $name
+   *   The name of the collection holding key and value pairs.
+   *
+   * @return \Drupal\Core\Queue\DatabaseQueue
+   *   A key/value store implementation for the given $collection.
+   */
+  public function get($name) {
+    $settings = $this->settings->get('redis_queue_' . $name, ['reserve_timeout' => NULL]);
+    $class_name = $this->clientFactory->getClass(static::CLASS_NAMESPACE);
+    return new $class_name($name, $settings, $this->clientFactory->getClient());
+  }
+
+}

sites/all/modules/contrib/dev/redis/src/Queue/ReliablePhpRedis.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+/**
+ * Redis queue implementation using PhpRedis extension backend.
+ *
+ * @ingroup queue
+ */
+class ReliablePhpRedis extends ReliableQueueBase {
+
+  /**
+   * The Redis connection.
+   *
+   * @var \Redis $client
+   */
+  protected $client;
+
+  /**
+   * Constructs a \Drupal\redis\Queue\PhpRedis object.
+   *
+   * @param string $name
+   *   The name of the queue.
+   * @param array $settings
+   *   Array of Redis-related settings for this queue.
+   * @param \Redis $client
+   *   The PhpRedis client.
+   */
+  public function __construct($name, array $settings, \Redis $client) {
+    parent::__construct($name, $settings);
+    $this->client = $client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createItem($data) {
+    $record = new \stdClass();
+    $record->data = $data;
+    $record->qid = $this->incrementId();
+    // We cannot rely on REQUEST_TIME because many items might be created
+    // by a single request which takes longer than 1 second.
+    $record->timestamp = time();
+
+    $result = $this->client->multi()
+      ->hsetnx($this->availableItems, $record->qid, serialize($record))
+      ->lLen($this->availableListKey)
+      ->lpush($this->availableListKey, $record->qid)
+      ->exec();
+
+    $success = $result[0] && $result[2] > $result[1];
+
+    return $success ? $record->qid : FALSE;
+  }
+
+  /**
+   * Gets next serial ID for Redis queue items.
+   *
+   * @return int
+   *   Next serial ID for Redis queue item.
+   */
+  protected function incrementId() {
+    return $this->client->incr($this->incrementCounterKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function numberOfItems() {
+    return $this->client->lLen($this->availableListKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function claimItem($lease_time = 30) {
+    // Is it OK to do garbage collection here (we need to loop list of claimed
+    // items)?
+    $this->garbageCollection();
+    $item = FALSE;
+
+    if ($this->reserveTimeout !== NULL) {
+      // A blocking version of claimItem to be used with long-running queue workers.
+      $qid = $this->client->brpoplpush($this->availableListKey, $this->claimedListKey, $this->reserveTimeout);
+    }
+    else {
+      $qid = $this->client->rpoplpush($this->availableListKey, $this->claimedListKey);
+    }
+
+    if ($qid) {
+      $job = $this->client->hget($this->availableItems, $qid);
+      if ($job) {
+        $item = unserialize($job);
+        $this->client->setex($this->leasedKeyPrefix . $item->qid, $lease_time, '1');
+      }
+    }
+
+    return $item;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseItem($item) {
+    $this->client->multi()
+      ->lrem($this->claimedListKey, $item->qid, -1)
+      ->lpush($this->availableListKey, $item->qid)
+      ->exec();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteItem($item) {
+    $this->client->multi()
+      ->lrem($this->claimedListKey, $item->qid, -1)
+      ->hdel($this->availableItems, $item->qid)
+      ->exec();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteQueue() {
+    $keys_to_remove = [
+      $this->claimedListKey,
+      $this->availableListKey,
+      $this->availableItems,
+      $this->incrementCounterKey
+    ];
+
+    foreach ($this->client->keys($this->leasedKeyPrefix . '*') as $key) {
+      $keys_to_remove[] = $key;
+    }
+
+    $this->client->del($keys_to_remove);
+  }
+
+  /**
+   * Automatically release items, that have been claimed and exceeded lease time.
+   */
+  protected function garbageCollection() {
+    foreach ($this->client->lrange($this->claimedListKey, 0, -1) as $qid) {
+      if (!$this->client->exists($this->leasedKeyPrefix . $qid)) {
+        // The lease expired for this ID.
+        $this->client->multi()
+          ->lrem($this->claimedListKey, $qid, -1)
+          ->lpush($this->availableListKey, $qid)
+          ->exec();
+      }
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/src/Queue/ReliablePredis.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+/**
+ * Redis queue implementation using Predis library backend.
+ *
+ * @ingroup queue
+ */
+class ReliablePredis extends ReliableQueueBase {
+
+  /**
+   * The Redis connection.
+   *
+   * @var \Predis\Client $client
+   */
+  protected $client;
+
+  /**
+   * Constructs a \Drupal\redis\Queue\Predis object.
+   *
+   * @param string $name
+   *   The name of the queue.
+   * @param array $settings
+   *   Array of Redis-related settings for this queue.
+   * @param \Predis\Client $client
+   *   The Predis client.
+   */
+  public function __construct($name, array $settings, \Predis\Client $client) {
+    parent::__construct($name, $settings);
+    $this->client = $client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createItem($data) {
+    $record = new \stdClass();
+    $record->data = $data;
+    $record->qid = $this->incrementId();
+    // We cannot rely on REQUEST_TIME because many items might be created
+    // by a single request which takes longer than 1 second.
+    $record->timestamp = time();
+
+    $pipe = $this->client->pipeline();
+    $pipe->hsetnx($this->availableItems, $record->qid, serialize($record));
+    $pipe->lLen($this->availableListKey);
+    $pipe->lpush($this->availableListKey, $record->qid);
+    $result = $pipe->execute();
+
+    $success = $result[0] && $result[2] > $result[1];
+
+    return $success ? $record->qid : FALSE;
+  }
+
+  /**
+   * Gets next serial ID for Redis queue items.
+   *
+   * @return int
+   *   Next serial ID for Redis queue item.
+   */
+  protected function incrementId() {
+    // TODO: Fixme
+    return $this->client->incr($this->incrementCounterKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function numberOfItems() {
+    // TODO: Fixme
+    return $this->client->lLen($this->availableListKey);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function claimItem($lease_time = 30) {
+    // Is it OK to do garbage collection here (we need to loop list of claimed
+    // items)?
+    $this->garbageCollection();
+    $item = FALSE;
+
+    if ($this->reserveTimeout !== NULL) {
+      // A blocking version of claimItem to be used with long-running queue workers.
+      $qid = $this->client->brpoplpush($this->availableListKey, $this->claimedListKey, $this->reserveTimeout);
+    }
+    else {
+      $qid = $this->client->rpoplpush($this->availableListKey, $this->claimedListKey);
+    }
+
+    if ($qid) {
+      $job = $this->client->hget($this->availableItems, $qid);
+      if ($job) {
+        $item = unserialize($job);
+        $this->client->setex($this->leasedKeyPrefix . $item->qid, $lease_time, '1');
+      }
+    }
+
+    return $item;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseItem($item) {
+    // TODO: Fixme
+    $this->client->pipeline()
+      ->lrem($this->claimedListKey, $item->qid, -1)
+      ->lpush($this->availableListKey, $item->qid)
+      ->exec();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteItem($item) {
+    // TODO: Fixme
+    $this->client->pipeline()
+      ->lrem($this->claimedListKey, $item->qid, -1)
+      ->hdel($this->availableItems, $item->qid)
+      ->exec();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteQueue() {
+    // TODO: Fixme
+    $keys_to_remove = [
+      $this->claimedListKey,
+      $this->availableListKey,
+      $this->availableItems,
+      $this->incrementCounterKey
+    ];
+
+    foreach ($this->client->keys($this->leasedKeyPrefix . '*') as $key) {
+      $keys_to_remove[] = $key;
+    }
+
+    $this->client->del($keys_to_remove);
+  }
+
+  /**
+   * Automatically release items, that have been claimed and exceeded lease time.
+   */
+  protected function garbageCollection() {
+    foreach ($this->client->lrange($this->claimedListKey, 0, -1) as $qid) {
+      if (!$this->client->exists($this->leasedKeyPrefix . $qid)) {
+        // The lease expired for this ID.
+        $this->client->lrem($this->claimedListKey, $qid, -1);
+        $this->client->lpush($this->availableListKey, $qid);
+      }
+    }
+  }
+}

sites/all/modules/contrib/dev/redis/src/Queue/ReliableQueueBase.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+use Drupal\Core\Queue\ReliableQueueInterface;
+
+/**
+ * Redis queue implementation.
+ *
+ * @ingroup queue
+ */
+abstract class ReliableQueueBase extends QueueBase implements ReliableQueueInterface {
+
+}

sites/all/modules/contrib/dev/redis/src/Queue/ReliableQueueRedisFactory.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\redis\Queue;
+
+use Drupal\redis\ClientFactory;
+
+/**
+ * Defines the queue factory for the Redis backend.
+ */
+class ReliableQueueRedisFactory extends QueueRedisFactory {
+
+  /**
+   * Queue implementation class namespace prefix.
+   */
+  const CLASS_NAMESPACE = ClientFactory::REDIS_IMPL_RELIABLE_QUEUE;
+
+}

sites/all/modules/contrib/dev/redis/src/RedisPrefixTrait.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Drupal\redis;
+
+use Drupal\Core\Site\Settings;
+
+trait RedisPrefixTrait {
+
+  /**
+   * @var string
+   */
+  protected $prefix;
+
+  /**
+   * Get global default prefix
+   *
+   * @param string $suffix
+   *
+   * @return string
+   */
+  protected function getDefaultPrefix($suffix = NULL) {
+    $ret = NULL;
+
+    if ($test_prefix = drupal_valid_test_ua()) {
+      $ret = $test_prefix;
+    }
+    else {
+      $prefixes = Settings::get('cache_prefix', '');
+
+      if (is_string($prefixes)) {
+        // Variable can be a string which then considered as a default
+        // behavior.
+        $ret = $prefixes;
+      }
+      else if (NULL !== $suffix && isset($prefixes[$suffix])) {
+        if (FALSE !== $prefixes[$suffix]) {
+          // If entry is set and not false an explicit prefix is set
+          // for the bin.
+          $ret = $prefixes[$suffix];
+        }
+        else {
+          // If we have an explicit false it means no prefix whatever
+          // is the default configuration.
+          $ret = '';
+        }
+      }
+      else {
+        // Key is not set, we can safely rely on default behavior.
+        if (isset($prefixes['default']) && FALSE !== $prefixes['default']) {
+          $ret = $prefixes['default'];
+        }
+        else {
+          // When default is not set or an explicit false this means
+          // no prefix.
+          $ret = '';
+        }
+      }
+    }
+
+    if (empty($ret)) {
+      // If no prefix is given, use the same logic as core for APCu caching.
+      $ret = Settings::getApcuPrefix('redis', DRUPAL_ROOT);
+    }
+
+    return $ret;
+  }
+
+  /**
+   * Set prefix
+   *
+   * @param string $prefix
+   */
+  public function setPrefix($prefix) {
+    $this->prefix = $prefix;
+  }
+
+  /**
+   * Get prefix
+   *
+   * @return string
+   */
+  protected function getPrefix() {
+    if (!isset($this->prefix)) {
+      $this->prefix = $this->getDefaultPrefix();
+    }
+    return $this->prefix;
+  }
+
+}

sites/all/modules/contrib/dev/redis/tests/src/Functional/Lock/RedisLockFunctionalTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\Tests\redis\Functional\Lock;
+
+use Drupal\Component\Utility\OpCodeCache;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Site\Settings;
+use Drupal\Tests\system\Functional\Lock\LockFunctionalTest;
+use Drupal\Tests\redis\Traits\RedisTestInterfaceTrait;
+
+/**
+ * Confirm locking works between two separate requests.
+ *
+ * @group redis
+ */
+class RedisLockFunctionalTest extends LockFunctionalTest {
+
+  use RedisTestInterfaceTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['redis'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Write the containers_yaml update by hand, since writeSettings() doesn't
+    // support this syntax.
+    $filename = $this->siteDirectory . '/settings.php';
+    chmod($filename, 0666);
+    $contents = file_get_contents($filename);
+    $redis_interface = self::getRedisInterfaceEnv();
+    $contents .= "\n\n" . '$settings[\'container_yamls\'][] = \'modules/redis/example.services.yml\';';
+    $contents .= "\n\n" . '$settings["redis.connection"]["interface"] = \'' . $redis_interface . '\';';
+    file_put_contents($filename, $contents);
+    $settings = Settings::getAll();
+    $settings['container_yamls'][] = 'modules/redis/example.services.yml';
+    $settings['redis.connection']['interface'] = '\'' .  $redis_interface . '\'';
+    new Settings($settings);
+    OpCodeCache::invalidate(DRUPAL_ROOT . '/' . $filename);
+
+    $this->rebuildContainer();
+
+    // Get database schema.
+    $db_schema = Database::getConnection()->schema();
+    // Make sure that the semaphore table isn't used.
+    $db_schema->dropTable('semaphore');
+  }
+
+}

sites/all/modules/contrib/dev/redis/tests/src/Functional/WebTest.php

@@ -0,0 +1,193 @@
+<?php
+
+namespace Drupal\Tests\redis\Functional;
+
+use Drupal\Component\Utility\OpCodeCache;
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Site\Settings;
+use Drupal\field_ui\Tests\FieldUiTestTrait;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\redis\Traits\RedisTestInterfaceTrait;
+
+/**
+ * Tests complex processes like installing modules with redis backends.
+ *
+ * @group redis
+ */
+class WebTest extends BrowserTestBase {
+
+  use FieldUiTestTrait;
+  use RedisTestInterfaceTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['redis', 'block'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->drupalPlaceBlock('system_breadcrumb_block');
+    $this->drupalPlaceBlock('local_tasks_block');
+
+    // Set in-memory settings.
+    $settings = Settings::getAll();
+
+    // Get REDIS_INTERFACE env variable.
+    $redis_interface = self::getRedisInterfaceEnv();
+    $settings['redis.connection']['interface'] = $redis_interface;
+
+    $settings['cache'] = [
+      'default' => 'cache.backend.redis',
+    ];
+
+    $settings['container_yamls'][] = drupal_get_path('module', 'redis') . '/example.services.yml';
+
+    $settings['bootstrap_container_definition'] = [
+      'parameters' => [],
+      'services' => [
+        'redis.factory' => [
+          'class' => 'Drupal\redis\ClientFactory',
+        ],
+        'cache.backend.redis' => [
+          'class' => 'Drupal\redis\Cache\CacheBackendFactory',
+          'arguments' => ['@redis.factory', '@cache_tags_provider.container', '@serialization.phpserialize'],
+        ],
+        'cache.container' => [
+          'class' => '\Drupal\redis\Cache\PhpRedis',
+          'factory' => ['@cache.backend.redis', 'get'],
+          'arguments' => ['container'],
+        ],
+        'cache_tags_provider.container' => [
+          'class' => 'Drupal\redis\Cache\RedisCacheTagsChecksum',
+          'arguments' => ['@redis.factory'],
+        ],
+        'serialization.phpserialize' => [
+          'class' => 'Drupal\Component\Serialization\PhpSerialize',
+        ],
+      ],
+    ];
+    new Settings($settings);
+
+    // Write the containers_yaml update by hand, since writeSettings() doesn't
+    // support some of the definitions.
+    $filename = $this->siteDirectory . '/settings.php';
+    chmod($filename, 0666);
+    $contents = file_get_contents($filename);
+
+    // Add the container_yaml and cache definition.
+    $contents .= "\n\n" . '$settings["container_yamls"][] = "' . drupal_get_path('module', 'redis') . '/example.services.yml";';
+    $contents .= "\n\n" . '$settings["cache"] = ' . var_export($settings['cache'], TRUE) . ';';
+
+    // Add the classloader.
+    $contents .= "\n\n" . '$class_loader->addPsr4(\'Drupal\\\\redis\\\\\', \'' . drupal_get_path('module', 'redis') . '/src\');';
+
+    // Add the bootstrap container definition.
+    $contents .= "\n\n" . '$settings["bootstrap_container_definition"] = ' . var_export($settings['bootstrap_container_definition'], TRUE) . ';';
+
+    file_put_contents($filename, $contents);
+    OpCodeCache::invalidate(DRUPAL_ROOT . '/' . $filename);
+
+    // Reset the cache factory.
+    $this->container->set('cache.factory', NULL);
+    $this->rebuildContainer();
+
+    // Get database schema.
+    $db_schema = Database::getConnection()->schema();
+
+    // Make sure that the cache and lock tables aren't used.
+    $db_schema->dropTable('cache_default');
+    $db_schema->dropTable('cache_render');
+    $db_schema->dropTable('cache_config');
+    $db_schema->dropTable('cache_container');
+    $db_schema->dropTable('cachetags');
+    $db_schema->dropTable('semaphore');
+    $db_schema->dropTable('flood');
+  }
+
+  /**
+   * Tests enabling modules and creating configuration.
+   */
+  public function testModuleInstallation() {
+    $admin_user = $this->createUser([], NULL, TRUE);
+    $this->drupalLogin($admin_user);
+
+    // Enable a few modules.
+    $edit["modules[node][enable]"] = TRUE;
+    $edit["modules[views][enable]"] = TRUE;
+    $edit["modules[field_ui][enable]"] = TRUE;
+    $edit["modules[text][enable]"] = TRUE;
+    $this->drupalPostForm('admin/modules', $edit, t('Install'));
+    $this->drupalPostForm(NULL, [], t('Continue'));
+
+    $assert = $this->assertSession();
+
+    // The order of the modules is not guaranteed, so just assert that they are
+    // all listed.
+    $assert->elementTextContains('css', '.messages--status', '6 modules have been enabled');
+    $assert->elementTextContains('css', '.messages--status', 'Field UI');
+    $assert->elementTextContains('css', '.messages--status', 'Node');
+    $assert->elementTextContains('css', '.messages--status', 'Text');
+    $assert->elementTextContains('css', '.messages--status', 'Views');
+    $assert->elementTextContains('css', '.messages--status', 'Field');
+    $assert->elementTextContains('css', '.messages--status', 'Filter');
+    $assert->checkboxChecked('edit-modules-field-ui-enable');
+
+    // Create a node type with a field.
+    $edit = [
+      'name' => $this->randomString(),
+      'type' => $node_type = Unicode::strtolower($this->randomMachineName()),
+    ];
+    $this->drupalPostForm('admin/structure/types/add', $edit, t('Save and manage fields'));
+    $field_name = Unicode::strtolower($this->randomMachineName());
+    $this->fieldUIAddNewField('admin/structure/types/manage/' . $node_type, $field_name, NULL, 'text');
+
+    // Create a node, check display, edit, verify that it has been updated.
+    $edit = [
+      'title[0][value]' => $this->randomMachineName(),
+      'body[0][value]' => $this->randomMachineName(),
+      'field_' . $field_name . '[0][value]' => $this->randomMachineName(),
+    ];
+    $this->drupalPostForm('node/add/' . $node_type, $edit, t('Save and publish'));
+
+    // Test the output as anonymous user.
+    $this->drupalLogout();
+    $this->drupalGet('node');
+    $this->assertSession()->responseContains($edit['title[0][value]']);
+
+    $this->drupalLogin($admin_user);
+    $this->drupalGet('node');
+    $this->clickLink($edit['title[0][value]']);
+    $this->assertSession()->responseContains($edit['body[0][value]']);
+    $this->clickLink(t('Edit'));
+    $update = [
+      'title[0][value]' => $this->randomMachineName(),
+    ];
+    $this->drupalPostForm(NULL, $update, t('Save and keep published'));
+    $this->assertSession()->responseContains($update['title[0][value]']);
+    $this->drupalGet('node');
+    $this->assertSession()->responseContains($update['title[0][value]']);
+
+    $this->drupalLogout();
+    $this->drupalGet('node');
+    $this->clickLink($update['title[0][value]']);
+    $this->assertSession()->responseContains($edit['body[0][value]']);
+
+    // Get database schema.
+    $db_schema = Database::getConnection()->schema();
+    $this->assertFalse($db_schema->tableExists('cache_default'));
+    $this->assertFalse($db_schema->tableExists('cache_render'));
+    $this->assertFalse($db_schema->tableExists('cache_config'));
+    $this->assertFalse($db_schema->tableExists('cache_container'));
+    $this->assertFalse($db_schema->tableExists('cachetags'));
+    $this->assertFalse($db_schema->tableExists('semaphore'));
+    $this->assertFalse($db_schema->tableExists('flood'));
+  }
+
+}

sites/all/modules/contrib/dev/redis/tests/src/Kernel/RedisCacheTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Drupal\Tests\redis\Kernel;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\KernelTests\Core\Cache\GenericCacheBackendUnitTestBase;
+use Symfony\Component\DependencyInjection\Reference;
+use Drupal\Tests\redis\Traits\RedisTestInterfaceTrait;
+
+/**
+ * Tests Redis cache backend using GenericCacheBackendUnitTestBase.
+ *
+ * @group redis
+ */
+class RedisCacheTest extends GenericCacheBackendUnitTestBase {
+
+  use RedisTestInterfaceTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['system', 'redis'];
+
+  public function register(ContainerBuilder $container) {
+    self::setUpSettings();
+    parent::register($container);
+    // Replace the default checksum service with the redis implementation.
+    if ($container->has('redis.factory')) {
+      $container->register('cache_tags.invalidator.checksum', 'Drupal\redis\Cache\RedisCacheTagsChecksum')
+        ->addArgument(new Reference('redis.factory'))
+        ->addTag('cache_tags_invalidator');
+    }
+  }
+
+  /**
+   * Creates a new instance of PhpRedis cache backend.
+   *
+   * @return \Drupal\redis\Cache\PhpRedis
+   *   A new PhpRedis cache backend.
+   */
+  protected function createCacheBackend($bin) {
+    $cache = \Drupal::service('cache.backend.redis')->get($bin);
+    $cache->setMinTtl(10);
+    return $cache;
+  }
+
+}

sites/all/modules/contrib/dev/redis/tests/src/Kernel/RedisFloodTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Drupal\Tests\redis\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\redis\Flood\PhpRedis;
+use Drupal\Tests\redis\Traits\RedisTestInterfaceTrait;
+
+/**
+ * Tests Redis flood backend.
+ *
+ * @group redis
+ */
+class RedisFloodTest extends KernelTestBase {
+
+  use RedisTestInterfaceTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['redis'];
+
+  /**
+   * Test flood control.
+   */
+  public function testFlood() {
+    self::setUpSettings();
+    $threshold = 2;
+    $window = 1;
+    $name = 'flood_test_cleanup';
+
+    $client_factory = \Drupal::service('redis.factory');
+    $request_stack = \Drupal::service('request_stack');
+    $flood = new PhpRedis($client_factory, $request_stack);
+
+    // By default the event is allowed.
+    $this->assertTrue($flood->isAllowed($name, $threshold));
+
+    // Register event.
+    $flood->register($name, $window);
+
+    // The event is still allowed.
+    $this->assertTrue($flood->isAllowed($name, $threshold));
+
+    $flood->register($name, $window);
+
+    // Verify event is not allowed.
+    $this->assertFalse($flood->isAllowed($name, $threshold));
+
+    // "Sleep" two seconds, then the event is allowed again.
+    $_SERVER['REQUEST_TIME'] += 2;
+    $this->assertTrue($flood->isAllowed($name, $threshold));
+
+  }
+
+}

sites/all/modules/contrib/dev/redis/tests/src/Kernel/RedisQueueTest.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Drupal\Tests\redis\Kernel;
+
+use Drupal\redis\ClientFactory;
+use \Drupal\KernelTests\Core\Queue\QueueTest as CoreQueueTest;
+use Drupal\Tests\redis\Traits\RedisTestInterfaceTrait;
+
+/**
+ * Tests the Redis queue functions.
+ *
+ * @group redis
+ */
+class RedisQueueTest extends CoreQueueTest {
+
+  use RedisTestInterfaceTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['redis'];
+
+  /**
+   * Tests Redis non-blocking queue.
+   */
+  public function testRedisNonBlockingQueue() {
+    self::setUpSettings();
+    $client_factory = \Drupal::service('redis.factory');
+    $settings = ['reserve_timeout' => NULL];
+    $class_name = $client_factory->getClass(ClientFactory::REDIS_IMPL_QUEUE);
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue1 */
+    $queue1 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue1->createQueue();
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue2 */
+    $queue2 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue2->createQueue();
+
+    $this->queueTest($queue1, $queue2);
+    $queue1->deleteQueue();
+    $queue2->deleteQueue();
+
+    $class_name = $client_factory->getClass(ClientFactory::REDIS_IMPL_RELIABLE_QUEUE);
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue1 */
+    $queue1 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue1->createQueue();
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue2 */
+    $queue2 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue2->createQueue();
+
+    $this->queueTest($queue1, $queue2);
+  }
+
+  /**
+   * Tests Redis blocking queue.
+   */
+  public function testRedisBlockingQueue() {
+    self::setUpSettings();
+    // Create two queues.
+    $client_factory = \Drupal::service('redis.factory');
+    $settings = ['reserve_timeout' => 30];
+    $class_name = $client_factory->getClass(ClientFactory::REDIS_IMPL_QUEUE);
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue1 */
+    $queue1 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue1->createQueue();
+
+    /** @var \Drupal\Core\Queue\QueueInterface $queue2 */
+    $queue2 = new $class_name($this->randomMachineName(), $settings, $client_factory->getClient());
+    $queue2->createQueue();
+
+    $this->queueTest($queue1, $queue2);
+  }
+
+  /**
+   * Overrides \Drupal\system\Tests\Queue\QueueTestQueueTest::testSystemQueue().
+   *
+   * We override tests from core class we extend to prevent them from running.
+   */
+  public function testSystemQueue() {}
+
+  /**
+   * Overrides \Drupal\system\Tests\Queue\QueueTestQueueTest::testMemoryQueue().
+   *
+   * We override tests from core class we extend to prevent them from running.
+   */
+  public function testMemoryQueue() {}
+
+}
+

sites/all/modules/contrib/dev/redis/tests/src/Traits/RedisTestInterfaceTrait.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\Tests\redis\Traits;
+
+use Drupal\Core\Site\Settings;
+
+trait RedisTestInterfaceTrait {
+
+  /**
+ * Uses an env variable to set the redis client to use for this test.
+ */
+  public function setUpSettings() {
+
+    // Write redis_interface settings manually.
+    $redis_interface = self::getRedisInterfaceEnv();
+    $settings = Settings::getAll();
+    $settings['redis.connection']['interface'] = $redis_interface;
+    new Settings($settings);
+  }
+
+  /**
+   * Uses an env variable to set the redis client to use for this test.
+   */
+  public function getRedisInterfaceEnv() {
+
+    // Get REDIS_INTERFACE from env variable.
+    $redis_interface = getenv('REDIS_INTERFACE');
+
+    // Default to PhpRedis is env variable not available.
+    if ($redis_interface == FALSE) {
+      $redis_interface = 'PhpRedis';
+    }
+    return $redis_interface;
+  }
+
+}