redis-rack 1.6.0 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fc742a461ac6cb3cd6b1cf5e6bac8fad3c704de8
-  data.tar.gz: 851c2fb3b482eb6f44e948d475cd1e7315cbb70d
+SHA256:
+  metadata.gz: 68b8d92fa59d3d7167cf87bd16e1e62ca34ba905a901964a6d386b47155f8da0
+  data.tar.gz: 3c8b27ef07b66c2050d053287c03eb3aee64860fda3e4ff806200d9cc663f7ec
 SHA512:
-  metadata.gz: ae3e5966785213132068f31674dd32dd0622316433757f59bb652a0f58461d752068f740b62948420851ccf247198ae2ef0feaf5ca7353784eb020d2e3ead9e3
-  data.tar.gz: 72f618348fb097d7cdb3057116ed79350a4ad2661d2eeeb93ce3e009c6b6b026a7eaee68810f6baefaf3bb5c0e60b083eceb6bf0bf3f79c33f1846846a110d46
+  metadata.gz: 351e468a771f67ed2e05c3620735636f23f7ad40e338d420c3662a2f7bfc1abdf82e3cf30c1e9a8268452ed1451e87740cc7fabb110b5c60251717a84b2c70f4
+  data.tar.gz: b93772d79076558bf42e60effd452a47699e215538e73435ec70f500ee8e2902b65b7c1f2eb40d4019884c12fbf81ab57b940702657b4295581abe820483631d

data/.github/auto-assign-issues.yml

@@ -0,0 +1,2 @@
+assignees:
+  - tubbo

data/.gitignore

@@ -2,3 +2,5 @@ Gemfile.lock
 *.gem
 tmp/
 stdout
+gemfiles/vendor
+gemfiles/*.gemfile.lock

data/.travis.yml

@@ -1,14 +1,22 @@
 language: ruby
-script: 'bundle exec rake'
+script: bundle exec rake
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - ruby-head
-  - rbx-19mode
-  - jruby-19mode
-  - jruby-head
-
+- 2.2.3
+- 2.3.1
+- ruby-head
+- jruby-head
 matrix:
   allow_failures:
-    - rvm: jruby-head
-    - rvm: ruby-head
+  - rvm: jruby-head
+  - rvm: ruby-head
+gemfile:
+- gemfiles/rack_2.gemfile
+- gemfiles/rack_1.gemfile
+deploy:
+  provider: rubygems
+  api_key:
+    secure: VTosVmCdLWUGK8KyzovYri7ySfd7fACtfL8MClEBBHnI+m2cLCpmtCJ7Z1X7z9BXlj974EDaF8V9iRKzfksXIf8aaPfVQw9AW94fLJZbfSB8YGOGyNbPu9YECoZQB1aZ2lw9s/aEdfwCbmqizO/fYpG3YoPKJdm1ZJpNOFR37Xk=
+  gem: redis-rack
+  on:
+    tags: true
+    repo: redis-store/redis-rack

data/Appraisals

@@ -0,0 +1,7 @@
+appraise 'rack-2' do
+  gem 'rack', '~> 2'
+end
+
+appraise 'rack-1' do
+  gem 'rack', '~> 1'
+end

data/CODEOWNERS

@@ -0,0 +1 @@
+* @tubbo

data/Gemfile

@@ -1,6 +1,2 @@
 source 'https://rubygems.org'
 gemspec
-
-if ::File.directory?(gem_path = '../redis-store')
-  gem 'redis-store', '~> 1.1.0', path: gem_path
-end

data/README.md

@@ -1,14 +1,37 @@
-# Redis stores for Rack
+# Redis session store for Rack
 
-__`redis-rack`__ provides a Redis backed session store __Rack__. See the main [redis-store readme](https://github.com/redis-store/redis-store) for general guidelines.
+__`redis-rack`__ provides a Redis-backed session store for __Rack__.
+
+See the main [redis-store readme] for general guidelines.
+
+**NOTE:** This is not [redis-rack-cache][], the library for using Redis
+as a backend store for the `Rack::Cache` HTTP cache. All this gem does
+is store the Rack session within Redis.
+
+[![Build Status](https://secure.travis-ci.org/redis-store/redis-rack.png?branch=master)](http://travis-ci.org/redis-store/redis-rack?branch=master)
+[![Code Climate](https://codeclimate.com/github/redis-store/redis-store.png)](https://codeclimate.com/github/redis-store/redis-rack)
+[![Gem Version](https://badge.fury.io/rb/redis-rack.png)](http://badge.fury.io/rb/redis-rack)
 
 ## Installation
 
+Install with Bundler by adding the following to Gemfile:
+
 ```ruby
-# Gemfile
 gem 'redis-rack'
 ```
 
+Then, run:
+
+```shell
+$ bundle install
+```
+
+Or, you can install it manually using RubyGems:
+
+```shell
+$ gem install redis-rack
+```
+
 ## Usage
 
 If you are using redis-store with Rails, consider using the [redis-rails gem](https://github.com/redis-store/redis-rails) instead. For standalone usage:
@@ -19,24 +42,42 @@ require 'rack'
 require 'rack/session/redis'
 
 use Rack::Session::Redis
+
+# Alternatively you can specify options to use:
+use Rack::Session::Redis,
+  :redis_server => "redis://redis:6379/0",
+  :expires_in => 3600 # Seconds. If you are using ActiveSupport you can use 1.hour
 ```
 
-## Running tests
+## Development
+
+To install this gem for development purposes:
 
 ```shell
-gem install bundler
-git clone git://github.com/redis-store/redis-rack.git
-cd redis-rack
-bundle install
-bundle exec rake
+$ gem install bundler # note: you don't need to do this if you already have it installed
+$ git clone git://github.com/redis-store/redis-rack.git
+$ cd redis-rack
+$ bundle install
 ```
 
-If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" bundle exec rake`
+## Running tests
 
-## Status
+To run tests:
 
-[![Gem Version](https://badge.fury.io/rb/redis-rack.png)](http://badge.fury.io/rb/redis-rack) [![Build Status](https://secure.travis-ci.org/redis-store/redis-rack.png?branch=master)](http://travis-ci.org/jodosha/redis-rack?branch=master) [![Code Climate](https://codeclimate.com/github/jodosha/redis-store.png)](https://codeclimate.com/github/redis-store/redis-rack)
+```shell
+$ bundle exec rake
+```
+
+If you are on **Snow Leopard** you have to run the following command to
+build this software:
+
+```shell
+$ env ARCHFLAGS="-arch x86_64" bundle exec rake
+```
 
 ## Copyright
 
 2009 - 2013 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license
+
+[redis-rack-cache]: https://github.com/redis-store/redis-rack-cache
+[redis-store readme]: https://github.com/redis-store/redis-store

data/Rakefile

@@ -2,3 +2,9 @@ require 'bundler/setup'
 require 'rake'
 require 'bundler/gem_tasks'
 require 'redis-store/testing/tasks'
+
+task :all do
+  Dir["gemfiles/*.gemfile"].reject { |p| p =~ /\.lock\Z/ }.each do |gemfile|
+    sh "BUNDLE_GEMFILE=#{gemfile} bundle exec rake"
+  end
+end

data/bin/appraisal

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'appraisal' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("appraisal", "appraisal")

data/bin/rake

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/gemfiles/rack_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rack", "~> 1"
+
+gemspec :path => "../"

data/gemfiles/rack_2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rack", "~> 2"
+
+gemspec :path => "../"

data/lib/rack/session/redis.rb

@@ -1,57 +1,69 @@
 require 'rack/session/abstract/id'
 require 'redis-store'
 require 'thread'
+require 'redis/rack/connection'
 
 module Rack
   module Session
     class Redis < Abstract::ID
-      attr_reader :mutex, :pool
+      attr_reader :mutex
 
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge(
         :redis_server => 'redis://127.0.0.1:6379/0/rack:session'
+      )
 
       def initialize(app, options = {})
         super
 
         @mutex = Mutex.new
-        @pool = ::Redis::Store::Factory.create @default_options[:redis_server]
+        @conn = ::Redis::Rack::Connection.new(@default_options)
       end
 
-      def generate_sid
+      def generate_unique_sid(session)
+        return generate_sid if session.empty?
         loop do
-          sid = super
-          break sid unless @pool.get(sid)
+          sid = generate_sid
+          first = with do |c|
+            [*c.setnx(sid, session, @default_options)].first
+          end
+          break sid if [1, true].include?(first)
         end
       end
 
       def get_session(env, sid)
-        with_lock(env, [nil, {}]) do
-          unless sid and session = @pool.get(sid)
-            sid, session = generate_sid, {}
-            unless /^OK/ =~ @pool.set(sid, session, @default_options)
-              raise "Session collision on '#{sid.inspect}'"
+        if env['rack.session.options'][:skip]
+          [generate_sid, {}]
+        else
+          with_lock(env, [nil, {}]) do
+            unless sid and session = with { |c| c.get(sid) }
+              session = {}
+              sid = generate_unique_sid(session)
             end
+            [sid, session]
           end
-          [sid, session]
         end
       end
 
       def set_session(env, session_id, new_session, options)
         with_lock(env, false) do
-          @pool.set session_id, new_session, options
+          with { |c| c.set session_id, new_session, options }
           session_id
         end
       end
 
       def destroy_session(env, session_id, options)
         with_lock(env) do
-          @pool.del(session_id)
+          with { |c| c.del(session_id) }
           generate_sid unless options[:drop]
         end
       end
 
+      def threadsafe?
+        @default_options.fetch(:threadsafe, true)
+      end
+
       def with_lock(env, default=nil)
-        @mutex.lock if env['rack.multithread']
+        @mutex.lock if env['rack.multithread'] && threadsafe?
         yield
       rescue Errno::ECONNREFUSED
         if $VERBOSE
@@ -63,7 +75,9 @@ module Rack
         @mutex.unlock if @mutex.locked?
       end
 
+      def with(&block)
+        @conn.with(&block)
+      end
     end
   end
 end
-

data/lib/redis/rack/connection.rb

@@ -0,0 +1,46 @@
+class Redis
+  module Rack
+    class Connection
+      def initialize(options = {})
+        @options = options
+        @store = options[:redis_store]
+        @pool = options[:pool]
+
+        if @pool && !@pool.is_a?(ConnectionPool)
+          raise ArgumentError, "pool must be an instance of ConnectionPool"
+        end
+
+        if @store && !@store.is_a?(Redis::Store)
+          raise ArgumentError, "redis_store must be an instance of Redis::Store (currently #{@store.class.name})"
+        end
+      end
+
+      def with(&block)
+        if pooled?
+          pool.with(&block)
+        else
+          block.call(store)
+        end
+      end
+
+      def pooled?
+        [:pool, :pool_size, :pool_timeout].any? { |key| @options.key?(key) }
+      end
+
+      def pool
+        @pool ||= ConnectionPool.new(pool_options) { store } if pooled?
+      end
+
+      def store
+        @store ||= Redis::Store::Factory.create(@options[:redis_server])
+      end
+
+      def pool_options
+        {
+          size: @options[:pool_size],
+          timeout: @options[:pool_timeout]
+        }.reject { |key, value| value.nil? }.to_h
+      end
+    end
+  end
+end

data/lib/redis/rack/version.rb

@@ -1,6 +1,6 @@
 class Redis
   module Rack
-    VERSION = '1.6.0'
+    VERSION = '2.0.6'
   end
 end
 

data/redis-rack.gemspec

@@ -16,16 +16,18 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = []
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'redis-store',   '~> 1.2.0'
-  s.add_runtime_dependency 'rack',          '~> 1.5'
+  s.add_runtime_dependency 'redis-store',   ['< 2', '>= 1.2']
+  s.add_runtime_dependency 'rack',          '>= 1.5', '< 3'
 
   s.add_development_dependency 'rake',     '~> 10'
   s.add_development_dependency 'bundler',  '~> 1.3'
   s.add_development_dependency 'mocha',    '~> 0.14.0'
   s.add_development_dependency 'minitest', '~> 5'
   s.add_development_dependency 'redis-store-testing'
+  s.add_development_dependency 'connection_pool',     '~> 1.2.0'
+  s.add_development_dependency 'appraisal'
 end
 

data/test/rack/session/redis_test.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 require 'rack/mock'
 require 'thread'
+require 'connection_pool'
 
 describe Rack::Session::Redis do
   session_key = Rack::Session::Redis::DEFAULT_OPTIONS[:key]
@@ -22,6 +23,10 @@ describe Rack::Session::Redis do
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
   end
+  skip_session = proc do |env|
+    env['rack.session.options'][:skip] = true
+    incrementor.call(env)
+  end
 
   # # test Redis connection
   # Rack::Session::Redis.new(incrementor)
@@ -32,155 +37,246 @@ describe Rack::Session::Redis do
   #   }.must_raise(Exception)
   # end
 
+  it "can create it's own pool" do
+    session_store = Rack::Session::Redis.new(incrementor, pool_size: 5, pool_timeout: 10)
+    conn = session_store.instance_variable_get(:@conn)
+    conn.pool.class.must_equal ::ConnectionPool
+    conn.pool.instance_variable_get(:@size).must_equal 5
+  end
+
+  it "can create it's own pool using default Redis server" do
+    session_store = Rack::Session::Redis.new(incrementor, pool_size: 5, pool_timeout: 10)
+    session_store.with { |connection| connection.to_s.must_match(/127\.0\.0\.1:6379 against DB 0 with namespace rack:session$/)  }
+  end
+
+  it "can create it's own pool using provided Redis server" do
+    session_store = Rack::Session::Redis.new(incrementor, redis_server: 'redis://127.0.0.1:6380/1', pool_size: 5, pool_timeout: 10)
+    session_store.with { |connection| connection.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)  }
+  end
+
+  it "can use a supplied pool" do
+    session_store = Rack::Session::Redis.new(incrementor, pool: ::ConnectionPool.new(size: 1, timeout: 1) { ::Redis::Store::Factory.create("redis://127.0.0.1:6380/1")})
+    conn = session_store.instance_variable_get(:@conn)
+    conn.pool.class.must_equal ::ConnectionPool
+    conn.pool.instance_variable_get(:@size).must_equal 1
+  end
+
+  it "uses the specified Redis store when provided" do
+    store = ::Redis::Store::Factory.create('redis://127.0.0.1:6380/1')
+    pool = Rack::Session::Redis.new(incrementor, :redis_store => store)
+    pool.with do |p|
+      p.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+      p.must_equal(store)
+    end
+  end
+
   it "uses the default Redis server and namespace when not provided" do
     pool = Rack::Session::Redis.new(incrementor)
-    pool.pool.to_s.must_match(/127\.0\.0\.1:6379 against DB 0 with namespace rack:session$/)
+    pool.with { |p| p.to_s.must_match(/127\.0\.0\.1:6379 against DB 0 with namespace rack:session$/) }
   end
 
   it "uses the specified namespace when provided" do
     pool = Rack::Session::Redis.new(incrementor, :redis_server => {:namespace => 'test:rack:session'})
-    pool.pool.to_s.must_match(/namespace test:rack:session$/)
+    pool.with { |p| p.to_s.must_match(/namespace test:rack:session$/) }
   end
 
   it "uses the specified Redis server when provided" do
     pool = Rack::Session::Redis.new(incrementor, :redis_server => 'redis://127.0.0.1:6380/1')
-    pool.pool.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+    pool.with { |p| p.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/) }
+  end
+
+  it "is threadsafe by default" do
+    sesion_store = Rack::Session::Redis.new(incrementor)
+    sesion_store.threadsafe?.must_equal(true)
+  end
+
+  it "does not store a blank session" do
+    session_store = Rack::Session::Redis.new(incrementor)
+    sid = session_store.generate_unique_sid({})
+    session_store.with { |c| c.get(sid).must_be_nil }
+  end
+
+  it "locks the store mutex" do
+    mutex = Mutex.new
+    mutex.expects(:lock).once
+    sesion_store = Rack::Session::Redis.new(incrementor)
+    sesion_store.instance_variable_set(:@mutex, mutex)
+    was_yielded = false
+    sesion_store.with_lock({'rack.multithread' => true}) { was_yielded = true}
+    was_yielded.must_equal(true)
+  end
+
+  describe "threadsafe disabled" do
+    it "can have the global lock disabled" do
+      sesion_store = Rack::Session::Redis.new(incrementor, :threadsafe => false)
+      sesion_store.threadsafe?.must_equal(false)
+    end
+
+    it "does not lock the store mutex" do
+      mutex = Mutex.new
+      mutex.expects(:lock).never
+      sesion_store = Rack::Session::Redis.new(incrementor, :threadsafe => false)
+      sesion_store.instance_variable_set(:@mutex, mutex)
+      was_yielded = false
+      sesion_store.with_lock({'rack.multithread' => true}) { was_yielded = true}
+      was_yielded.must_equal(true)
+    end
   end
 
   it "creates a new cookie" do
-    pool = Rack::Session::Redis.new(incrementor)
-    res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].must_include("#{session_key}=")
-    res.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      res = Rack::MockRequest.new(pool).get("/")
+      res["Set-Cookie"].must_include("#{session_key}=")
+      res.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "determines session from a cookie" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    res = req.get("/")
-    cookie = res["Set-Cookie"]
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.must_equal('{"counter"=>2}')
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.must_equal('{"counter"=>3}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      cookie = res["Set-Cookie"]
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.must_equal('{"counter"=>2}')
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "determines session only from a cookie by default" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    res = req.get("/")
-    sid = res["Set-Cookie"][session_match, 1]
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>1}')
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>1}')
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "determines session from params" do
-    pool = Rack::Session::Redis.new(incrementor, :cookie_only => false)
-    req = Rack::MockRequest.new(pool)
-    res = req.get("/")
-    sid = res["Set-Cookie"][session_match, 1]
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>2}')
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>3}')
+    with_pool_management(incrementor, :cookie_only => false) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>2}')
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "survives nonexistant cookies" do
     bad_cookie = "rack.session=blarghfasel"
-    pool = Rack::Session::Redis.new(incrementor)
-    res = Rack::MockRequest.new(pool).
-      get("/", "HTTP_COOKIE" => bad_cookie)
-    res.body.must_equal('{"counter"=>1}')
-    cookie = res["Set-Cookie"][session_match]
-    cookie.wont_match(/#{bad_cookie}/)
+    with_pool_management(incrementor) do |pool|
+      res = Rack::MockRequest.new(pool).
+        get("/", "HTTP_COOKIE" => bad_cookie)
+      res.body.must_equal('{"counter"=>1}')
+      cookie = res["Set-Cookie"][session_match]
+      cookie.wont_match(/#{bad_cookie}/)
+    end
   end
 
   it "maintains freshness" do
-    pool = Rack::Session::Redis.new(incrementor, :expire_after => 3)
-    res = Rack::MockRequest.new(pool).get('/')
-    res.body.must_include('"counter"=>1')
-    cookie = res["Set-Cookie"]
-    sid = cookie[session_match, 1]
-    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"][session_match, 1].must_equal(sid)
-    res.body.must_include('"counter"=>2')
-    puts 'Sleeping to expire session' if $DEBUG
-    sleep 4
-    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"][session_match, 1].wont_equal(sid)
-    res.body.must_include('"counter"=>1')
+    with_pool_management(incrementor, :expire_after => 3) do |pool|
+      res = Rack::MockRequest.new(pool).get('/')
+      res.body.must_include('"counter"=>1')
+      cookie = res["Set-Cookie"]
+      sid = cookie[session_match, 1]
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"][session_match, 1].must_equal(sid)
+      res.body.must_include('"counter"=>2')
+      puts 'Sleeping to expire session' if $DEBUG
+      sleep 4
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"][session_match, 1].wont_equal(sid)
+      res.body.must_include('"counter"=>1')
+    end
   end
 
   it "does not send the same session id if it did not change" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
 
-    res0 = req.get("/")
-    cookie = res0["Set-Cookie"]
-    res0.body.must_equal('{"counter"=>1}')
+      res0 = req.get("/")
+      cookie = res0["Set-Cookie"]
+      res0.body.must_equal('{"counter"=>1}')
 
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"].must_be_nil
-    res1.body.must_equal('{"counter"=>2}')
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      res1["Set-Cookie"].must_be_nil
+      res1.body.must_equal('{"counter"=>2}')
 
-    res2 = req.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].must_be_nil
-    res2.body.must_equal('{"counter"=>3}')
+      res2 = req.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "deletes cookies with :drop option" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    drop = Rack::Utils::Context.new(pool, drop_session)
-    dreq = Rack::MockRequest.new(drop)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.must_equal('{"counter"=>1}')
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].must_be_nil
-    res2.body.must_equal('{"counter"=>2}')
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].wont_equal(session)
-    res3.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      drop = Rack::Utils::Context.new(pool, drop_session)
+      dreq = Rack::MockRequest.new(drop)
+
+      res1 = req.get("/")
+      session = (cookie = res1["Set-Cookie"])[session_match]
+      res1.body.must_equal('{"counter"=>1}')
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal('{"counter"=>2}')
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie)
+      res3["Set-Cookie"][session_match].wont_equal(session)
+      res3.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "provides new session id with :renew option" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    renew = Rack::Utils::Context.new(pool, renew_session)
-    rreq = Rack::MockRequest.new(renew)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.must_equal('{"counter"=>1}')
-
-    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
-    new_cookie = res2["Set-Cookie"]
-    new_session = new_cookie[session_match]
-    new_session.wont_equal(session)
-    res2.body.must_equal('{"counter"=>2}')
-
-    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3.body.must_equal('{"counter"=>3}')
-
-    # Old cookie was deleted
-    res4 = req.get("/", "HTTP_COOKIE" => cookie)
-    res4.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      renew = Rack::Utils::Context.new(pool, renew_session)
+      rreq = Rack::MockRequest.new(renew)
+
+      res1 = req.get("/")
+      session = (cookie = res1["Set-Cookie"])[session_match]
+      res1.body.must_equal('{"counter"=>1}')
+
+      res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+      new_cookie = res2["Set-Cookie"]
+      new_session = new_cookie[session_match]
+      new_session.wont_equal(session)
+      res2.body.must_equal('{"counter"=>2}')
+
+      res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+      res3.body.must_equal('{"counter"=>3}')
+
+      # Old cookie was deleted
+      res4 = req.get("/", "HTTP_COOKIE" => cookie)
+      res4.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "omits cookie with :defer option" do
-    pool = Rack::Session::Redis.new(incrementor)
-    defer = Rack::Utils::Context.new(pool, defer_session)
-    dreq = Rack::MockRequest.new(defer)
+    with_pool_management(incrementor) do |pool|
+      defer = Rack::Utils::Context.new(pool, defer_session)
+      dreq = Rack::MockRequest.new(defer)
+
+      res0 = dreq.get("/")
+      res0["Set-Cookie"].must_be_nil
+      res0.body.must_equal('{"counter"=>1}')
+    end
+  end
 
-    res0 = dreq.get("/")
-    res0["Set-Cookie"].must_be_nil
-    res0.body.must_equal('{"counter"=>1}')
+  it "does not hit with :skip option" do
+    with_pool_management(incrementor) do |session_store|
+      skip = Rack::Utils::Context.new(session_store, skip_session)
+      sreq = Rack::MockRequest.new(skip)
+
+      res0 = sreq.get("/")
+      res0.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "updates deep hashes correctly" do
@@ -194,17 +290,18 @@ describe Rack::Session::Redis do
       end
       [200, {}, [session.inspect]]
     end
-    pool = Rack::Session::Redis.new(hash_check)
-    req = Rack::MockRequest.new(pool)
+    with_pool_management(hash_check) do |pool|
+      req = Rack::MockRequest.new(pool)
 
-    res0 = req.get("/")
-    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
-    ses0 = pool.pool.get(session_id)
+      res0 = req.get("/")
+      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+      ses0 = pool.with { |c| c.get(session_id) }
 
-    req.get("/", "HTTP_COOKIE" => cookie)
-    ses1 = pool.pool.get(session_id)
+      req.get("/", "HTTP_COOKIE" => cookie)
+      ses1 = pool.with { |c| c.get(session_id) }
 
-    ses1.wont_equal(ses0)
+      ses1.wont_equal(ses0)
+    end
   end
 
   # anyone know how to do this better?
@@ -214,76 +311,98 @@ describe Rack::Session::Redis do
       next
     end
     warn 'Running multithread test for Session::Redis'
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-
-    res = req.get('/')
-    res.body.must_equal('{"counter"=>1}')
-    cookie = res["Set-Cookie"]
-    session_id = cookie[session_match, 1]
-
-    delta_incrementor = lambda do |env|
-      # emulate disconjoinment of threading
-      env['rack.session'] = env['rack.session'].dup
-      Thread.stop
-      env['rack.session'][(Time.now.usec*rand).to_i] = true
-      incrementor.call(env)
-    end
-    tses = Rack::Utils::Context.new pool, delta_incrementor
-    treq = Rack::MockRequest.new(tses)
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do
-      Thread.new(treq) do |run|
-        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+
+      res = req.get('/')
+      res.body.must_equal('{"counter"=>1}')
+      cookie = res["Set-Cookie"]
+      session_id = cookie[session_match, 1]
+
+      delta_incrementor = lambda do |env|
+        # emulate disconjoinment of threading
+        env['rack.session'] = env['rack.session'].dup
+        Thread.stop
+        env['rack.session'][(Time.now.usec*rand).to_i] = true
+        incrementor.call(env)
+      end
+      tses = Rack::Utils::Context.new pool, delta_incrementor
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].must_equal(cookie)
+        request.body.must_include('"counter"=>2')
+      end
+
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(tnum+1) # counter
+      session['counter'].must_equal(2) # meeeh
+
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do |i|
+        app = Rack::Utils::Context.new pool, time_delta
+        req = Rack::MockRequest.new app
+        Thread.new(req) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].must_equal(cookie)
+        request.body.must_include('"counter"=>3')
       end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |request|
-      request['Set-Cookie'].must_equal(cookie)
-      request.body.must_include('"counter"=>2')
-    end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(tnum+1) # counter
-    session['counter'].must_equal(2) # meeeh
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(tnum+1)
+      session['counter'].must_equal(3)
 
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do |i|
-      app = Rack::Utils::Context.new pool, time_delta
-      req = Rack::MockRequest.new app
-      Thread.new(req) do |run|
-        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+      drop_counter = proc do |env|
+        env['rack.session'].delete 'counter'
+        env['rack.session']['foo'] = 'bar'
+        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+      end
+      tses = Rack::Utils::Context.new pool, drop_counter
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].must_equal(cookie)
+        request.body.must_include('"foo"=>"bar"')
       end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |request|
-      request['Set-Cookie'].must_equal(cookie)
-      request.body.must_include('"counter"=>3')
+
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(r.size+1)
+      session['counter'].must_be_nil
+      session['foo'].must_equal('bar')
     end
+  end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(tnum+1)
-    session['counter'].must_equal(3)
+  private
+    def with_pool_management(*args)
+      yield simple(*args)
+      yield pooled(*args)
+      yield external_pooled(*args)
+    end
 
-    drop_counter = proc do |env|
-      env['rack.session'].delete 'counter'
-      env['rack.session']['foo'] = 'bar'
-      [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+    def simple(app, options = {})
+      Rack::Session::Redis.new(app, options)
     end
-    tses = Rack::Utils::Context.new pool, drop_counter
-    treq = Rack::MockRequest.new(tses)
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do
-      Thread.new(treq) do |run|
-        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
-      end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |request|
-      request['Set-Cookie'].must_equal(cookie)
-      request.body.must_include('"foo"=>"bar"')
+
+    def pooled(app, options = {})
+      Rack::Session::Redis.new(app, options)
+      Rack::Session::Redis.new(app, options.merge(pool_size: 5, pool_timeout: 10))
+    end
+
+    def external_pooled(app, options = {})
+      Rack::Session::Redis.new(app, options.merge(pool: ::ConnectionPool.new(size: 1, timeout: 1) { ::Redis::Store::Factory.create("redis://127.0.0.1:6380/1") }))
     end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(r.size+1)
-    session['counter'].must_be_nil
-    session['foo'].must_equal('bar')
-  end
 end

data/test/redis/rack/connection_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+require 'connection_pool'
+require 'redis/rack/connection'
+
+class Redis
+  module Rack
+    describe Connection do
+      def setup
+        @defaults = {
+          host: 'localhost'
+        }
+      end
+
+      it "can create it's own pool" do
+        conn = Connection.new @defaults.merge(pool_size: 5, pool_timeout: 10)
+
+        conn.pooled?.must_equal true
+        conn.pool.class.must_equal ConnectionPool
+        conn.pool.instance_variable_get(:@size).must_equal 5
+      end
+
+      it "can create it's own pool using default Redis server" do
+        conn = Connection.new @defaults.merge(pool_size: 5, pool_timeout: 10)
+
+        conn.pooled?.must_equal true
+
+        conn.with do |connection|
+          connection.to_s.must_match(/127\.0\.0\.1:6379 against DB 0$/)
+        end
+      end
+
+      it "can create it's own pool using provided Redis server" do
+        conn = Connection.new(redis_server: 'redis://127.0.0.1:6380/1', pool_size: 5, pool_timeout: 10)
+        conn.pooled?.must_equal true
+        conn.with do |connection|
+          connection.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+        end
+      end
+
+      it "can use a supplied pool" do
+        pool = ConnectionPool.new size: 1, timeout: 1 do
+          ::Redis::Store::Factory.create('redis://127.0.0.1:6380/1')
+        end
+        conn = Connection.new pool: pool
+        conn.pooled?.must_equal true
+        conn.pool.class.must_equal ConnectionPool
+        conn.pool.instance_variable_get(:@size).must_equal 1
+      end
+
+      it "uses the specified Redis store when provided" do
+        store = ::Redis::Store::Factory.create('redis://127.0.0.1:6380/1')
+        conn = Connection.new(redis_store: store)
+
+        conn.pooled?.must_equal false
+        conn.store.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+        conn.store.must_equal(store)
+      end
+
+      it "throws an error when provided Redis store is not the expected type" do
+        assert_raises ArgumentError do
+          Connection.new(redis_store: ::Redis.new)
+        end
+      end
+
+      it "uses the specified Redis server when provided" do
+        conn = Connection.new(redis_server: 'redis://127.0.0.1:6380/1')
+
+        conn.pooled?.must_equal false
+        conn.store.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+      end
+
+      it "does not include nil options for the connection pool" do
+        conn = Connection.new
+        conn.pool_options.must_be_empty
+
+        conn = Connection.new(pool_size: nil)
+        conn.pool_options.must_be_empty
+
+        conn = Connection.new(pool_timeout: nil)
+        conn.pool_options.must_be_empty
+      end
+    end
+  end
+end

metadata

@@ -1,111 +1,151 @@
 --- !ruby/object:Gem::Specification
 name: redis-rack
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.6
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-04 00:00:00.000000000 Z
+date: 2019-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-store
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: redis-store-testing
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Redis Store for Rack applications
@@ -115,18 +155,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".github/auto-assign-issues.yml"
+- ".gitignore"
+- ".travis.yml"
+- Appraisals
+- CODEOWNERS
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
+- bin/appraisal
+- bin/rake
+- gemfiles/rack_1.gemfile
+- gemfiles/rack_2.gemfile
 - lib/rack/session/redis.rb
 - lib/redis-rack.rb
+- lib/redis/rack/connection.rb
 - lib/redis/rack/version.rb
 - redis-rack.gemspec
 - test/rack/session/redis_test.rb
-- test/redis/rack/version_test.rb
+- test/redis/rack/connection_test.rb
 - test/test_helper.rb
 homepage: http://redis-store.org/redis-rack
 licenses:
@@ -138,21 +186,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: redis-rack
-rubygems_version: 2.5.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Redis Store for Rack
 test_files:
 - test/rack/session/redis_test.rb
-- test/redis/rack/version_test.rb
+- test/redis/rack/connection_test.rb
 - test/test_helper.rb

data/test/redis/rack/version_test.rb

@@ -1,7 +0,0 @@
-require 'test_helper'
-
-describe Redis::Rack::VERSION do
-  it 'returns current version' do
-    Redis::Rack::VERSION.must_equal '1.5.0'
-  end
-end