redis-actionpack-json 4.0.0

data/redis-actionpack-json/test/redis/actionpack/version_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+describe Redis::ActionPack::VERSION do
+  it "must be equal to 3.2.3" do
+    Redis::ActionPack::VERSION.must_equal '3.2.3'
+  end
+end

data/redis-actionpack-json/test/test_helper.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+require 'active_support/core_ext/numeric/time'
+
+ENV["RAILS_ENV"] = "test"
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+def with_autoload_path(path)
+  path = File.join(File.dirname(__FILE__), "fixtures", path)
+  if ActiveSupport::Dependencies.autoload_paths.include?(path)
+    yield
+  else
+    begin
+      ActiveSupport::Dependencies.autoload_paths << path
+      yield
+    ensure
+      ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+      ActiveSupport::Dependencies.clear
+    end
+  end
+end

data/redis-rack-json/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*

data/redis-rack-json/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'redis-store', '~> 1.1.0', :path => File.expand_path('../../redis-store', __FILE__)
+gem 'SystemTimer', :platform => :mri_18

data/redis-rack-json/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 - 2011 Luca Guidi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/redis-rack-json/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler.setup
+require 'rake'
+require 'bundler/gem_tasks'
+
+load 'tasks/redis.tasks.rb'
+task :default => 'redis:test:suite'
+

data/redis-rack-json/lib/rack/session/redis.rb

@@ -0,0 +1,69 @@
+require 'rack/session/abstract/id'
+require 'redis-store-json'
+require 'thread'
+
+module Rack
+  module Session
+    class Redis < Abstract::ID
+      attr_reader :mutex, :pool
+
+      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::Factory.create @default_options
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid)
+        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)
+              raise "Session collision on '#{sid.inspect}'"
+            end
+          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
+          session_id
+        end
+      end
+
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          @pool.del(session_id)
+          generate_sid unless options[:drop]
+        end
+      end
+
+      def with_lock(env, default=nil)
+        @mutex.lock if env['rack.multithread']
+        yield
+      rescue Errno::ECONNREFUSED
+        if $VERBOSE
+          warn "#{self} is unable to find Redis server."
+          warn $!.inspect
+        end
+        default
+      ensure
+        @mutex.unlock if @mutex.locked?
+      end
+
+    end
+  end
+end
+

data/redis-rack-json/lib/redis-rack-json.rb

@@ -0,0 +1,3 @@
+require 'redis-store-json'
+require 'redis/rack/version'
+require 'rack/session/redis'

data/redis-rack-json/lib/redis/rack/version.rb

@@ -0,0 +1,6 @@
+class Redis
+  module Rack
+    VERSION = '1.5.2'
+  end
+end
+

data/redis-rack-json/redis-rack-json.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'redis/rack/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'redis-rack-json'
+  s.version     = Redis::Rack::VERSION
+  s.authors     = ["Nathan Tsoi", "Luca Guidi", "Matt Horan"]
+  s.email       = ["nathan@vertile.com"]
+  s.homepage    = "http://github.com/nathantsoi/redis-store-json"
+  s.summary     = "Rails 4 Redis session store for ActionPack with JSON serialization"
+  s.description = "Rails 4 Redis session store for ActionPack with JSON serialization"
+
+  s.rubyforge_project = 'redis-rack-json'
+
+  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.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'redis-store-json',   '~> 3.0.0'
+  s.add_runtime_dependency 'rack',          '~> 1.5.2'
+
+  s.add_development_dependency 'rake',     '~> 10'
+  s.add_development_dependency 'bundler',  '~> 1.2'
+  s.add_development_dependency 'mocha',    '~> 0.13.0'
+  s.add_development_dependency 'minitest', '~> 4.3.1'
+end
+

data/redis-rack-json/test/rack/session/redis_test.rb

@@ -0,0 +1,289 @@
+require 'test_helper'
+require 'rack/mock'
+require 'thread'
+
+describe Rack::Session::Redis do
+  session_key = Rack::Session::Redis::DEFAULT_OPTIONS[:key]
+  session_match = /#{session_key}=([0-9a-fA-F]+);/
+  incrementor = lambda do |env|
+    env["rack.session"]["counter"] ||= 0
+    env["rack.session"]["counter"] += 1
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  end
+  drop_session = proc do |env|
+    env['rack.session.options'][:drop] = true
+    incrementor.call(env)
+  end
+  renew_session = proc do |env|
+    env['rack.session.options'][:renew] = true
+    incrementor.call(env)
+  end
+  defer_session = proc do |env|
+    env['rack.session.options'][:defer] = true
+    incrementor.call(env)
+  end
+
+  # # test Redis connection
+  # Rack::Session::Redis.new(incrementor)
+  #
+  # it "faults on no connection" do
+  #   lambda{
+  #     Rack::Session::Redis.new(incrementor, :redis_server => 'nosuchserver')
+  #   }.must_raise(Exception)
+  # 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$/)
+  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$/)
+  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$/)
+  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}')
+  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}')
+  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}')
+  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}')
+  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}/)
+  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')
+  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)
+
+    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}')
+
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].must_be_nil
+    res2.body.must_equal('{"counter"=>3}')
+  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}')
+  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}')
+  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)
+
+    res0 = dreq.get("/")
+    res0["Set-Cookie"].must_be_nil
+    res0.body.must_equal('{"counter"=>1}')
+  end
+
+  it "updates deep hashes correctly" do
+    hash_check = proc do |env|
+      session = env['rack.session']
+      unless session.include? 'test'
+        session.update :a => :b, :c => { :d => :e },
+          :f => { :g => { :h => :i} }, 'test' => true
+      else
+        session[:f][:g][:h] = :j
+      end
+      [200, {}, [session.inspect]]
+    end
+    pool = Rack::Session::Redis.new(hash_check)
+    req = Rack::MockRequest.new(pool)
+
+    res0 = req.get("/")
+    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+    ses0 = pool.pool.get(session_id)
+
+    req.get("/", "HTTP_COOKIE" => cookie)
+    ses1 = pool.pool.get(session_id)
+
+    ses1.wont_equal(ses0)
+  end
+
+  # anyone know how to do this better?
+  it "cleanly merges sessions when multithreaded" do
+    unless $DEBUG
+      1.must_equal(1) # fake assertion to appease the mighty bacon
+      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)
+      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
+
+    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
+
+    session = pool.pool.get(session_id)
+    session.size.must_equal(tnum+1)
+    session['counter'].must_equal(3)
+
+    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
+
+    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