rack_session_redis_store 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+before_install:
+  - gem instal redis-namespace

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rack_session_redis_store.gemspec
+gemspec
+
+gem 'redis'
+gem 'redis-namespace'
+
+group :test do
+  gem 'rspec'
+  gem 'rspec-core'
+  gem 'rake'
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Spring_MT
+
+MIT License
+
+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/README.md

@@ -0,0 +1,25 @@
+# RackSessionRedisStore [![Build Status](https://travis-ci.org/SpringMT/rack_session_redis_store.png)](https://travis-ci.org/SpringMT/rack_session_redis_store)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rack_session_redis_store'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack_session_redis_store
+
+## Usage
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+task :test do
+  require 'rspec/core'
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:test) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+  end
+end
+

data/lib/rack_session_redis_store/version.rb

@@ -0,0 +1,3 @@
+module RackSessionRedisStore
+  VERSION = "0.0.1"
+end

data/lib/rack_session_redis_store.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+
+require 'thread'
+require 'base64'
+require 'rack/session/abstract/id'
+require 'redis_json_serializer'
+
+#
+# == Synopsis
+#
+# session store in redis
+#
+# == Description
+#
+# === Example
+#
+# === Features
+#
+# == HOWTOs
+#
+
+
+module RackSessionRedisStore
+  class Session < ::Rack::Session::Abstract::ID
+    attr_reader :mutex, :pool
+    DEFAULT_OPTIONS = ::Rack::Session::Abstract::ID::DEFAULT_OPTIONS
+
+    def initialize(app, options = {})
+      super
+      @mutex = Mutex.new
+      host = options[:host] || '127.0.0.1'
+      port = options[:port] || 6379
+      namespace = options[:namespace] || :session
+      @pool  = RedisJsonSerializer::Serializer.new(host: host, port: port, namespace: namespace)
+    end
+
+    def generate_sid
+      loop do
+        sid = super
+        break sid unless @pool.get sid
+      end
+    end
+
+    # === Synopsis
+    # call at call -> context -> prepare_session -> SessionHash.new  in rack/session/abstract/id.rb
+    #
+    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
+        if session.has_key? :flash
+          session[:flash] = Marshal.load(::Base64.decode64(session[:flash]))
+        end
+        [sid, session]
+      end
+    end
+
+    # === Synopsis
+    # call at call -> context -> commit_session in rack/session/abstract/id.rb
+    #
+    def set_session(env, session_id, new_session, options)
+      with_lock(env, false) do
+        if new_session.has_key? 'flash'
+          new_session['flash'] = ::Base64.encode64(Marshal.dump(new_session['flash']))
+        end
+        if ttl = options[:expire_after]
+          @pool.setex session_id, ttl, new_session
+        else
+          @pool.set session_id, new_session
+        end
+        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

data/rack_session_redis_store.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack_session_redis_store/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rack_session_redis_store"
+  gem.version       = RackSessionRedisStore::VERSION
+  gem.authors       = ["Spring_MT"]
+  gem.email         = ["today.is.sky.blue.sky@gmail.com"]
+  gem.summary       = %q{Rack session using redis. Corresponding to Rails :flash}
+  gem.homepage      = "https://github.com/SpringMT/rack_session_redis_store"
+
+  gem.rubyforge_project = 'rack_session_redis_store'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'rack', '~> 1.4'
+  gem.add_dependency 'redis_json_serializer', '>= 0'
+
+  gem.description = <<description
+description
+
+end

data/spec/rack_session_redis_store_spec.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'rack/mock'
+require 'thread'
+require 'json'
+
+describe RackSessionRedisStore::Session do
+  session_key = RackSessionRedisStore::Session::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
+
+  it "creates a new cookie" do
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    res = Rack::MockRequest.new(pool).get("/")
+    res["Set-Cookie"].should be_include("#{session_key}=")
+    res.body.should be_eql('{"counter"=>1}')
+  end
+
+  it "determines session from a cookie" do
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+    res = req.get("/")
+    cookie = res["Set-Cookie"]
+    req.get("/", "HTTP_COOKIE" => cookie).
+     body.should be_eql('{"counter"=>2}')
+    req.get("/", "HTTP_COOKIE" => cookie).
+      body.should be_eql('{"counter"=>3}')
+  end
+
+  it "determines session only from a cookie by default" do
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+    res = req.get("/")
+    sid = res["Set-Cookie"][session_match, 1]
+    req.get("/?rack.session=#{sid}").
+      body.should be_eql('{"counter"=>1}')
+    req.get("/?rack.session=#{sid}").
+      body.should be_eql('{"counter"=>1}')
+  end
+
+  it "determines session from params" do
+    pool = RackSessionRedisStore::Session.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.should be_eql('{"counter"=>2}')
+    req.get("/?rack.session=#{sid}").
+      body.should be_eql('{"counter"=>3}')
+  end
+
+  it "survives nonexistant cookies" do
+    bad_cookie = "rack.session=blarghfasel"
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    res = Rack::MockRequest.new(pool).
+      get("/", "HTTP_COOKIE" => bad_cookie)
+    res.body.should be_eql('{"counter"=>1}')
+    cookie = res["Set-Cookie"][session_match]
+    cookie.should_not match(/#{bad_cookie}/)
+  end
+
+  it "maintains freshness" do
+    pool = RackSessionRedisStore::Session.new(incrementor, :expire_after => 3)
+    res = Rack::MockRequest.new(pool).get('/')
+    res.body.should be_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].should be_eql(sid)
+    res.body.should be_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].should_not be_eql(sid)
+    res.body.should be_include('"counter"=>1')
+  end
+
+  it "does not send the same session id if it did not change" do
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+
+    res0 = req.get("/")
+    cookie = res0["Set-Cookie"]
+    res0.body.should be_eql('{"counter"=>1}')
+
+    res1 = req.get("/", "HTTP_COOKIE" => cookie)
+    res1["Set-Cookie"].should be_nil
+    res1.body.should be_eql('{"counter"=>2}')
+
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should be_nil
+    res2.body.should be_eql('{"counter"=>3}')
+  end
+
+  it "deletes cookies with :drop option" do
+    pool = RackSessionRedisStore::Session.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.should be_eql('{"counter"=>1}')
+
+    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should be_nil
+    res2.body.should be_eql('{"counter"=>2}')
+
+    res3 = req.get("/", "HTTP_COOKIE" => cookie)
+    res3["Set-Cookie"][session_match].should_not be_eql(session)
+    res3.body.should be_eql('{"counter"=>1}')
+  end
+
+  it "provides new session id with :renew option" do
+    pool = RackSessionRedisStore::Session.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.should be_eql('{"counter"=>1}')
+
+    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+    new_cookie = res2["Set-Cookie"]
+    new_session = new_cookie[session_match]
+    new_session.should_not be_eql(session)
+    res2.body.should be_eql('{"counter"=>2}')
+
+    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+    res3.body.should be_eql('{"counter"=>3}')
+
+    # Old cookie was deleted
+    res4 = req.get("/", "HTTP_COOKIE" => cookie)
+    res4.body.should be_eql('{"counter"=>1}')
+  end
+
+  it "omits cookie with :defer option" do
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    defer = Rack::Utils::Context.new(pool, defer_session)
+    dreq = Rack::MockRequest.new(defer)
+
+    res0 = dreq.get("/")
+    res0["Set-Cookie"].should be_nil
+    res0.body.should be_eql('{"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 = RackSessionRedisStore::Session.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.should_not be_eql(ses0)
+  end
+
+  # anyone know how to do this better?
+  it "cleanly merges sessions when multithreaded" do
+    unless $DEBUG
+      1.should be_eql(1) # fake assertion to appease the mighty bacon
+      next
+    end
+    warn 'Running multithread test for RackSessionRedisStore::Session'
+    pool = RackSessionRedisStore::Session.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+
+    res = req.get('/')
+    res.body.should be_eql('{"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'].should be_eql(cookie)
+      request.body.should be_include('"counter"=>2')
+    end
+
+    session = pool.pool.get(session_id)
+    session.size.should be_eql(tnum+1) # counter
+    session['counter'].should be_eql(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'].should be_eql(cookie)
+      request.body.should be_include('"counter"=>3')
+    end
+
+    session = pool.pool.get(session_id)
+    session.size.should be_eql(tnum+1)
+    session['counter'].should be_eql(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'].should be_eql(cookie)
+      request.body.should be_include('"foo"=>"bar"')
+    end
+
+    session = pool.pool.get(session_id)
+    session.size.should be_eql(r.size+1)
+    session['counter'].should be_nil
+    session['foo'].should be_eql('bar')
+  end
+
+  it "handles a flash object" do
+    flash_set = proc do |env|
+      session = env['rack.session']
+      session[:flash] = {notice: 'notice foo', alert: 'alert bar'}
+      # get_session() is called when session is refferd first
+      [200, {}, [session[:flash]]] ## set_session() is called at last
+    end
+    flash_get = proc do |env|
+      session = env['rack.session']
+      [200, {}, [session['flash']]]
+    end
+    pool_set = RackSessionRedisStore::Session.new flash_set
+    req0 = Rack::MockRequest.new pool_set
+    res = req0.get "/"
+    cookie = res["Set-Cookie"]
+    cookie.should be_include "#{session_key}="
+    pool_get = RackSessionRedisStore::Session.new flash_get
+    req1 = Rack::MockRequest.new pool_get
+    body1 = req1.get("/", "HTTP_COOKIE" => cookie).body
+    # Rack::MockRequest returns a to_s body. See lib/rack/mock.rb
+    body1.should eql({notice: 'notice foo', alert: 'alert bar'}.to_s)
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
+
+require 'rspec'
+
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rack_session_redis_store'
+
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: rack_session_redis_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Spring_MT
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70122680270940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70122680270940
+- !ruby/object:Gem::Dependency
+  name: redis_json_serializer
+  requirement: &70122680270400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70122680270400
+description: ''
+email:
+- today.is.sky.blue.sky@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rack_session_redis_store.rb
+- lib/rack_session_redis_store/version.rb
+- rack_session_redis_store.gemspec
+- spec/rack_session_redis_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/SpringMT/rack_session_redis_store
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rack_session_redis_store
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Rack session using redis. Corresponding to Rails :flash
+test_files:
+- spec/rack_session_redis_store_spec.rb
+- spec/spec_helper.rb
+has_rdoc: