mongo_session_store 2.0.0 → 3.0.0.beta.1

data/gemfiles/rails-4.0-mongo.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongo"
+
+gem "rails", "4.0"
+gem "devise", "~> 3.5"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails-4.0-mongoid.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongoid"
+
+gem "rails", "4.0"
+gem "devise", "~> 3.5"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails-4.1-mongo.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongo"
+
+gem "rails", "4.1"
+gem "devise", Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.1") ? "3.5.10" : ">= 4.2"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails-4.1-mongoid.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongoid"
+
+gem "rails", "4.1"
+gem "devise", Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.1") ? "3.5.10" : ">= 4.2"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails-4.2-mongo.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongo"
+
+gem "rails", "4.2"
+gem "devise", Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.1") ? "3.5.10" : ">= 4.2"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails-4.2-mongoid.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "mongoid"
+
+gem "rails", "4.2"
+gem "devise", Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.1") ? "3.5.10" : ">= 4.2"
+gem "sqlite3"
+
+gemspec :path => "../"

data/lib/mongo_session_store.rb

@@ -1 +1,27 @@
-$:.unshift File.dirname(__FILE__)
+module MongoSessionStore
+  def self.collection_name
+    @collection_name
+  end
+
+  def self.collection_name=(name)
+    @collection_name = name
+
+    if defined?(MongoidStore::Session)
+      MongoidStore::Session.store_in \
+        :collection => MongoSessionStore.collection_name
+    end
+
+    MongoStore::Session.reset_collection if defined?(MongoStore::Session)
+
+    @collection_name
+  end
+end
+
+if defined?(Mongoid)
+  require "mongo_session_store/mongoid_store"
+elsif defined?(Mongo)
+  require "mongo_session_store/mongo_store"
+end
+
+# Default collection name for all the stores.
+MongoSessionStore.collection_name = "sessions"

data/lib/mongo_session_store/mongo_store.rb

@@ -0,0 +1,102 @@
+require "mongo_session_store/mongo_store_base"
+
+module ActionDispatch
+  module Session
+    class MongoStore < MongoStoreBase
+      class Session
+        class << self
+          attr_writer :database
+
+          def load(options = {})
+            options[:data] = options["data"] if options["data"]
+            options[:data] =
+              if options[:data]
+                unpack(options[:data])
+              else
+                {}
+              end
+            new(options)
+          end
+
+          def where(query = {})
+            collection.find(query).map { |doc| load(doc) }
+          end
+
+          def database
+            return @database if @database
+
+            raise NoMongoClientError, "MongoStore needs a database, e.g. "\
+              "MongoStore::Session.database = Mongo::Client.new("\
+              "[\"127.0.0.1:27017\"], database: \"my_app_development\")"
+          end
+
+          def collection
+            @collection ||= database[MongoSessionStore.collection_name]
+          end
+
+          def reset_collection
+            @collection = nil
+          end
+
+          private
+
+          def unpack(packed)
+            return unless packed
+            data = packed.respond_to?(:data) ? packed.data : packed.to_s
+            Marshal.load(StringIO.new(data))
+          end
+        end
+
+        class NoMongoClientError < StandardError; end
+
+        attr_accessor :_id, :data, :created_at, :updated_at
+
+        def initialize(options = {})
+          @_id        = options[:_id]
+          @data       = options[:data]
+          @created_at = options[:created_at]
+          @updated_at = options[:updated_at]
+        end
+
+        def save
+          @created_at ||= Time.now.utc
+          @updated_at = Time.now.utc
+
+          scope.replace_one(attributes_for_save, :upsert => true)
+        end
+
+        def destroy
+          scope.delete_one
+        end
+
+        private
+
+        def collection
+          self.class.collection
+        end
+
+        def attributes_for_save
+          {
+            :data => pack(data),
+            :created_at => created_at,
+            :updated_at => updated_at
+          }
+        end
+
+        def scope
+          collection.find(:_id => _id)
+        end
+
+        def pack(data)
+          BSON::Binary.new(Marshal.dump(data || {}), :generic)
+        end
+
+        def unpack(packed)
+          self.class.unpack(packed)
+        end
+      end
+    end
+  end
+end
+
+MongoStore = ActionDispatch::Session::MongoStore

data/lib/mongo_session_store/mongo_store_base.rb

@@ -0,0 +1,65 @@
+require "action_dispatch/middleware/session/abstract_store"
+
+module ActionDispatch
+  module Session
+    class MongoStoreBase < AbstractStore
+      SESSION_RECORD_KEY = "rack.session.record".freeze
+      ENV_SESSION_OPTIONS_KEY = Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY
+
+      def self.session_class
+        self::Session
+      end
+
+      private
+
+      def session_class
+        self.class.session_class
+      end
+
+      def get_session(env, sid)
+        id, record = find_or_initialize_session(sid)
+        env[SESSION_RECORD_KEY] = record
+        [id, record.data]
+      end
+
+      def set_session(env, sid, session_data, _options = {})
+        id, record = get_session_record(env, sid)
+        record.data = session_data
+        yield if block_given?
+        # 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 find_or_initialize_session(id)
+        existing_session = (id && session_class.where(:_id => id).first)
+        session = existing_session if existing_session
+        session ||= session_class.new(:_id => generate_sid)
+        [session._id, session]
+      end
+
+      def get_session_record(env, sid)
+        if 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 destroy_session(env, _session_id, options)
+        destroy(env)
+        generate_sid unless options[:drop]
+      end
+
+      def destroy(env)
+        sid = current_session_id(env)
+        return unless sid
+
+        _, record = get_session_record(env, sid)
+        record.destroy
+        env[SESSION_RECORD_KEY] = nil
+      end
+    end
+  end
+end

data/lib/mongo_session_store/mongoid_store.rb

@@ -0,0 +1,52 @@
+require "mongo_session_store/mongo_store_base"
+
+module ActionDispatch
+  module Session
+    class MongoidStore < MongoStoreBase
+      class Session
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        attr_writer :data
+
+        store_in :collection => MongoSessionStore.collection_name
+
+        field :_data, :type => BSON::Binary, :default => -> { pack({}) }
+
+        def self.pack(data)
+          BSON::Binary.new(Marshal.dump(data), :generic)
+        end
+
+        def data
+          @data ||= unpack(_data)
+        end
+
+        def reload
+          @data = nil
+          super
+        end
+
+        private
+
+        before_save do
+          self._data = pack(data)
+        end
+
+        def pack(data)
+          self.class.pack(data)
+        end
+
+        def unpack(packed)
+          return unless packed
+          if packed.respond_to? :data
+            Marshal.load(packed.data)
+          else
+            Marshal.load(packed.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+MongoidStore = ActionDispatch::Session::MongoidStore

data/lib/mongo_session_store/version.rb

@@ -0,0 +1,3 @@
+module MongoSessionStore
+  VERSION = "3.0.0.beta.1".freeze
+end

data/mongo_session_store.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path("../lib/mongo_session_store/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "mongo_session_store"
+  s.version = MongoSessionStore::VERSION
+
+  s.authors          = ["Tom de Bruijn", "Brian Hempel", "Nicolas M\303\251rouze", "Tony Pitale", "Chris Brickley"]
+  s.email            = ["tom@tomdebruijn.com"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec,perf}/*`.split("\n")
+  s.homepage         = "http://github.com/mongoid/mongo_session_store"
+  s.license          = "MIT"
+  s.require_paths    = ["lib"]
+  s.summary          = "Rails session stores for Mongoid, or any other ODM. Rails 4 compatible."
+  s.required_ruby_version = ">= 1.9"
+
+  s.add_dependency "actionpack", "~> 4.0"
+  s.add_dependency "mongo", "~> 2.0"
+
+  s.add_development_dependency "rspec-rails", "~> 3"
+  s.add_development_dependency "pry", "~> 0.10"
+  s.add_development_dependency "rake", "~> 11"
+  s.add_development_dependency "rubocop", "0.45.0"
+  s.add_development_dependency "mongoid-danger", "~> 0.1.0"
+end

data/perf/benchmark.rb

@@ -0,0 +1,101 @@
+require "rubygems"
+require "bundler/setup"
+require "benchmark"
+require "action_dispatch"
+require "mongoid"
+require "mongo_session_store"
+require "mongo_session_store/mongoid_store"
+require "mongo_session_store/mongo_store"
+require File.expand_path("../../lib/mongo_session_store", __FILE__)
+
+Mongo::Logger.logger.level = Logger::FATAL
+Mongoid.logger.level = Logger::FATAL
+
+RUNS = 2000
+
+def benchmark(test_name)
+  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.drop
+
+  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
+    ids << store.send(
+      :set_session,
+      env.merge("rack.session.options" => { :id => nil }), nil, env["rack.session"]
+    )
+  end
+
+  ids.shuffle!
+
+  benchmark "session load" do
+    id = ids.pop
+    local_env = { "rack.request.cookie_hash" => { "_session_id" => id } }
+    _, data = store.send(:get_session, local_env, id)
+    if data[:something] != "not nothing" || data[:a_bunch_of_floats_in_embedded_docs][0][:float_a] != 3.141
+      puts data
+      raise "saved and fetched data do not match!"
+    end
+  end
+
+  database = collection.database
+  stats = database.command(:collstats => collection.name).documents.first
+  puts "Collection: #{collection.namespace}"
+  puts "           Total Size: #{stats["size"]}"
+  puts "         Object count: #{stats["count"]}"
+  puts "  Average object size: #{stats["avgObjSize"]}"
+  puts "          Index sizes: #{stats["indexSizes"].inspect}"
+end
+
+MongoSessionStore.collection_name = "session_collection"
+MongoStore::Session.database =
+  Mongo::Client.new(["127.0.0.1:27017"], :database => "mongo_test_database")
+Mongoid.configure do |c|
+  c.load_configuration(
+    "clients" => {
+      "default" => {
+        "database" => "mongoid_test_database",
+        "hosts" => ["127.0.0.1:27017"]
+      }
+    }
+  )
+end
+
+puts "MongoidStore..."
+mongoid_store = MongoidStore.new(nil)
+benchmark_store(mongoid_store)
+
+puts "MongoStore..."
+mongo_store = MongoStore.new(nil)
+benchmark_store(mongo_store)