mongo_session_store-rails5 7.0.0

data/lib/mongo_session_store/mongo_store_base.rb

@@ -0,0 +1,98 @@
+require 'action_dispatch/middleware/session/abstract_store'
+
+module ActionDispatch
+  module Session
+    class MongoStoreBase < AbstractStore
+
+      SESSION_RECORD_KEY = Rack::RACK_SESSION
+      begin
+        ENV_SESSION_OPTIONS_KEY = Rack::RACK_SESSION_OPTIONS
+      rescue NameError
+        # Rack 1.2.x has access to the ENV_SESSION_OPTIONS_KEY
+      end
+
+      def self.session_class
+        self::Session
+      end
+
+      private
+        def session_class
+          self.class.session_class
+        end
+
+        def generate_sid
+          # 20 random bytes in url-safe base64
+          SecureRandom.base64(20).gsub('=','').gsub('+','-').gsub('/','_')
+        end
+
+        def get_session(env, sid)
+          sid, record = find_or_initialize_session(sid)
+          env[SESSION_RECORD_KEY] = record
+          [sid, unpack(record.data)]
+        end
+
+        def find_session(env, sid)
+          get_session(env, sid)
+        end
+
+        def set_session(env, sid, session_data, options = {})
+          id, record = get_session_record(env, sid)
+          record.data = pack(session_data)
+          # Rack spec dictates that set_session should return true or false
+          # depending on whether or not the session was saved or not.
+          # However, ActionPack seems to want a session id instead.
+          record.save ? id : false
+        end
+
+        def write_session(env, sid, session_data, options = {})
+          set_session(env, sid, session_data, options)
+        end
+
+
+        def find_or_initialize_session(sid)
+          session = (sid && session_class.where(:_id => sid).first) || session_class.new(:_id => generate_sid)
+          [session._id, session]
+        end
+
+        def get_session_record(env, sid)
+          if env.env[ENV_SESSION_OPTIONS_KEY][:id].nil? || !env[SESSION_RECORD_KEY]
+            sid, env[SESSION_RECORD_KEY] = find_or_initialize_session(sid)
+          end
+
+          [sid, env[SESSION_RECORD_KEY]]
+        end
+
+        def delete_session(env, sid, options)
+          destroy_session(env, sid, options)
+        end
+
+        def destroy_session(env, sid, options)
+          unless options[:renew]
+            destroy(env)
+            generate_sid if !options[:drop] or options[:renew]
+          else
+            sid
+          end
+        end
+
+        def destroy(env)
+          if sid = current_session_id(env)
+            _, record = get_session_record(env, sid)
+            record.destroy
+            env[SESSION_RECORD_KEY] = nil
+          end
+        end
+
+        def pack(data)
+          Marshal.dump(data)
+        end
+
+        def unpack(packed)
+          return nil unless packed
+          data = packed.respond_to?(:data) ? packed.data : packed.to_s
+          Marshal.load(StringIO.new(data))
+        end
+
+    end
+  end
+end

data/lib/mongo_session_store/mongoid_store.rb

@@ -0,0 +1,57 @@
+require 'mongoid'
+require 'mongo_session_store/mongo_store_base'
+
+module ActionDispatch
+  module Session
+    class MongoidStore < MongoStoreBase
+      BINARY_CLASS = defined?(Moped::BSON::Binary) ? Moped::BSON::Binary : BSON::Binary
+
+      class Session
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        store_in :collection => MongoSessionStore.collection_name
+
+        if Mongoid::Fields::Validators::Macro::OPTIONS.include? :overwrite
+          field :_id, :type => String, :overwrite => true
+        else
+          field :_id, :type => String
+        end
+        field :data, :type => BINARY_CLASS, :default => -> { marshaled_binary({}) }
+        attr_accessible :_id, :data if respond_to?(:attr_accessible)
+
+        def marshaled_binary(data)
+          self.class.marshaled_binary(data)
+        end
+
+        def self.marshaled_binary(data)
+          if BINARY_CLASS.to_s == 'BSON::Binary'
+            BSON::Binary.new(Marshal.dump(data), :generic)
+          else
+            Moped::BSON::Binary.new(:generic, Marshal.dump(data))
+          end
+        end
+      end
+
+      private
+      def pack(data)
+        session_class.marshaled_binary(data)
+      end
+
+      def unpack(packed)
+        return nil unless packed
+        Marshal.load(extract_data(packed))
+      end
+
+      def extract_data(packed)
+        if packed.class.to_s == 'BSON::Binary'
+          packed.data
+        else
+          packed.to_s
+        end
+      end
+    end
+  end
+end
+
+MongoidStore = ActionDispatch::Session::MongoidStore

data/lib/mongo_session_store/version.rb

@@ -0,0 +1,3 @@
+module MongoSessionStore
+  VERSION = "7.0.0"
+end

data/mongo_session_store-rails3.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path('../lib/mongo_session_store/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = File.basename(__FILE__).gsub(".gemspec", "")
+  s.version = MongoSessionStore::VERSION
+
+  s.authors          = ["Brian Hempel", "Nicolas M\303\251rouze", "Tony Pitale", "Chris Brickley"]
+  s.email            = ["plasticchicken@gmail.com"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features,perf}/*`.split("\n")
+  s.homepage         = "http://github.com/brianhempel/mongo_session_store"
+  s.license          = "MIT"
+  s.require_paths    = ["lib"]
+  s.rubygems_version = "1.3.7"
+  s.summary          = "Rails session stores for MongoMapper, Mongoid, or any other ODM. Rails 3.1, 3.2, 4.0, 4.1, and 4.2 compatible."
+
+  s.add_dependency "actionpack", ">= 3.1"
+end

data/mongo_session_store-rails4.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path('../lib/mongo_session_store/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = File.basename(__FILE__).gsub(".gemspec", "")
+  s.version = MongoSessionStore::VERSION
+
+  s.authors          = ["Brian Hempel", "Nicolas M\303\251rouze", "Tony Pitale", "Chris Brickley"]
+  s.email            = ["plasticchicken@gmail.com"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features,perf}/*`.split("\n")
+  s.homepage         = "http://github.com/brianhempel/mongo_session_store"
+  s.license          = "MIT"
+  s.require_paths    = ["lib"]
+  s.rubygems_version = "1.3.7"
+  s.summary          = "Rails session stores for MongoMapper, Mongoid, or any other ODM. Rails 3.1, 3.2, 4.0, 4.1, and 4.2 compatible."
+
+  s.add_dependency "actionpack", ">= 3.1"
+end

data/mongo_session_store-rails5.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/mongo_session_store/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = File.basename(__FILE__).gsub(".gemspec", "")
+  s.version = MongoSessionStore::VERSION
+
+  s.authors          = ["Alexander Kiseliev", "Brian Hempel", "Nicolas M\303\251rouze", "Tony Pitale", "Chris Brickley"]
+  s.email            = ["i43ack@gmail.com", "plasticchicken@gmail.com"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features,perf}/*`.split("\n")
+  s.homepage         = "https://github.com/ack43/mongo_session_store"
+  s.license          = "MIT"
+  s.require_paths    = ["lib"]
+  s.rubygems_version = "1.3.7"
+  s.summary          = "Rails session stores for MongoMapper, Mongoid, or any other ODM. Rails 5.0 compatible."
+
+  s.add_dependency "actionpack", ">= 3.1"
+
+  s.add_dependency 'rails', ['>=5.0', "<6.0"]
+end

data/perf/benchmark.rb

@@ -0,0 +1,92 @@
+require 'benchmark'
+require 'rubygems'
+require 'bundler/setup'
+require 'action_dispatch'
+require File.expand_path('../../lib/mongo_session_store-rails3', __FILE__)
+
+MongoMapper.database = "test_session_stores"
+# get around Mongoid's unnecessary "requires MongoDB 2.0.0" error which is NOT triggered when loading from mongo.yml!
+Mongoid.config.from_hash('database' => "test_session_stores", 'logger' => false)
+
+RUNS = 2000
+
+def benchmark(test_name, &block)
+  sleep 2 # cool off for my poor laptop
+  time = Benchmark.realtime do
+    RUNS.times do 
+      yield
+    end
+  end
+  puts "#{(time/RUNS*100_000).round / 100.0}ms per #{test_name}"
+end
+
+def benchmark_store(store)
+  collection = store.class.session_class.collection
+  collection.remove
+  
+  large_session =  {
+    :something => "not nothing",
+    :left => "not right",
+    :welcome => "not despised",
+    :visits => [
+      "http://www.google.com",
+      "localhost:3000",
+      "http://localhost:3000/increment_session",
+      "http://www.iso.org/iso/country_codes/iso_3166_code_lists/iso-3166-1_decoding_table.htm",
+      "http://www.geonames.org/search.html?q=2303+australia&country="
+    ],
+    :one_k_of_data => "a"*1024,
+    :another_k => "b"*1024,
+    :more_data => [5]*500,
+    :too_much_data_for_a_cookie => "c"*8000,
+    :a_bunch_of_floats_in_embedded_docs => [{:float_a => 3.141, :float_b => -1.1}]*100
+  }
+  
+  ids = []
+
+  env = {
+    'rack.session'               => large_session,
+    'rack.session.options'       => { :id => store.send(:generate_sid) }
+  }
+  benchmark "session save" do
+    id = store.send(:generate_sid)
+    ids << id
+    store.send(:set_session, env.merge({'rack.session.options' => { :id => id }}), id, env['rack.session'])
+    # store.send(:commit_session, env.merge({'rack.session.options' => { :id => ids.last }}), 200, {}, [])
+  end
+
+  ids.shuffle!
+  
+  env = {
+    'rack.request.cookie_string' => "",
+    'HTTP_COOKIE'                => "",
+    'rack.request.cookie_hash'   => { '_session_id' => store.class.session_class.last._id }
+  }
+  benchmark "session load" do
+    id = ids.pop
+    local_env = env.merge({'rack.request.cookie_hash'   => { '_session_id' => id }})
+    # store.send(:prepare_session, local_env)
+    sid, data = store.send(:get_session, local_env, id)
+    # something = local_env['rack.session']["something"] # trigger the load
+    raise data.inspect unless data[:something] == "not nothing" && data[:a_bunch_of_floats_in_embedded_docs][0] == {:float_a => 3.141, :float_b => -1.1} 
+  end
+  
+  stats = collection.stats
+  puts "           Total Size: #{stats['size']}"
+  puts "         Object count: #{stats['count']}"
+  puts "  Average object size: #{stats['avgObjSize']}"
+  puts "          Index sizes: #{stats['indexSizes'].inspect}"
+end
+
+mongo_mapper_store = MongoMapperStore.new(nil)
+mongoid_store = MongoidStore.new(nil)
+mongo_store = MongoStore.new(nil)
+
+puts "MongoMapperStore..."
+benchmark_store(mongo_mapper_store)
+
+puts "MongoidStore..."
+benchmark_store(mongoid_store)
+
+puts "MongoStore..."
+benchmark_store(mongo_store)

data/release.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/bash
+bundle update
+git add --all .
+git commit -am "${*:1}"
+git push
+rake release

data/spec/integration_with_devise_spec.rb

@@ -0,0 +1,89 @@
+require 'rails_helper'
+
+describe Devise::SessionsController do
+  def create_user
+    post_data = {
+       'user[email]'                 => 'person@example.com',
+       'user[password]'              => 'secret',
+       'user[password_confirmation]' => 'secret'
+    }
+    post '/users', post_data
+  end
+  
+  def login
+    post_data = {
+       'user[email]'                 => 'person@example.com',
+       'user[password]'              => 'secret',
+       'user[password_confirmation]' => 'secret'
+    }
+    post '/users/sign_in', post_data
+  end
+  
+  def logout
+    delete '/users/sign_out'
+  end
+  
+  def i_should_be_logged_in
+    controller.user_signed_in?.should be_true
+    get '/'
+    response.body.squish.should =~ /You are logged in as person@example.com/
+  end
+
+  def i_should_not_be_logged_in
+    controller.user_signed_in?.should be_false
+    get '/'
+    response.body.squish.should =~ /You are logged out/
+  end
+    
+  it "does not explode" do
+  end
+  
+  it "allows user creation" do
+    User.count.should == 0
+    create_user
+    response.status.should == 302
+    get response.redirect_url
+    User.count.should == 1
+    response.body.squish.should =~ /You are logged in as person@example.com/
+    response.body.squish.should =~ /You have signed up successfully/
+  end
+  
+  it "allows user logout" do
+    create_user
+    i_should_be_logged_in
+    logout
+    response.status.should == 302
+    i_should_not_be_logged_in
+    response.body.squish.should =~ /Signed out successfully/
+  end
+  
+  it "allows user login" do
+    create_user
+    logout
+    i_should_not_be_logged_in
+    login
+    response.status.should == 302
+    i_should_be_logged_in
+    response.body.squish.should =~ /Signed in successfully/
+  end
+  
+  it "uses the right session store class" do
+    store = Rails.application.config.session_store
+    store.session_class.to_s.should == "ActionDispatch::Session::#{ENV["MONGO_SESSION_STORE_ORM"].camelize}Store::Session"
+  end
+  
+  it "stores the session in the sessions collection" do
+    collection = db["sessions"]
+    collection.find.count.should == 0
+    create_user
+    collection.find.count.should == 1
+  end
+  
+  it "allows renaming of the collection that stores the sessions" do
+    collection = db["dance_parties"]
+    collection.find.count.should == 0
+    MongoSessionStore.collection_name = "dance_parties"
+    create_user
+    collection.find.count.should == 1
+  end
+end

data/spec/mongo_store_base_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'securerandom'
+require 'ostruct'
+require 'mongo_session_store/mongo_store_base'
+
+describe ActionDispatch::Session::MongoStoreBase do
+  ENV_SESSION_OPTIONS_KEY = ActionDispatch::Session::MongoStoreBase::ENV_SESSION_OPTIONS_KEY
+  SESSION_RECORD_KEY      = ActionDispatch::Session::MongoStoreBase::SESSION_RECORD_KEY
+
+  Session = ActionDispatch::Session::MongoStoreBase::Session = Class.new(OpenStruct)
+
+  before do
+    @app   = nil
+    @store = ActionDispatch::Session::MongoStoreBase.new(@app)
+    @env   = {}
+  end
+
+  describe "#get_session" do
+    it "generates a new session id if given a nil session id" do
+      Session.stub(where: [])
+
+      sid, session_data = @store.send(:get_session, @env, nil)
+
+      sid.should_not                        == nil
+      session_data.should                   == nil
+      @env[SESSION_RECORD_KEY].class.should == Session
+      @env[SESSION_RECORD_KEY]._id.should   == sid
+    end
+
+    it "generates a new session id if session is not found" do
+      old_sid = SecureRandom.hex
+      Session.stub(where: [])
+
+      sid, session_data = @store.send(:get_session, @env, old_sid)
+
+      sid.should_not                        == old_sid
+      session_data.should                   == nil
+      @env[SESSION_RECORD_KEY].class.should == Session
+      @env[SESSION_RECORD_KEY]._id.should   == sid
+    end
+  end
+end