rack-session-rethinkdb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e787a86f4e27f5e0c3f38c5dafaad7ac7106e385
+  data.tar.gz: 831a1af09e0d0d71040762cb70ad4bb1e318d1b2
+SHA512:
+  metadata.gz: 6e72c5e4121c33d6fd1735872fb7df1b1c30accb687ddef088291f1221b8cdba57ad46656b41561c09b8931879777045c898f21c42e5128ebf697510dade3261
+  data.tar.gz: edeb347d93712503c3858a058c715fd1efd9c211019724710041d87240a8e22179db11aae82020fe7955665c1f79ade61f341e95be6db558ab2b1f7fcdd9423f

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Change Log
+
+## 0.1.0
+
+* Initial release

data/README.md

@@ -0,0 +1,23 @@
+# rack-session-rethinkdb
+
+Store rack sessions in a RethinkDB table.
+
+## Installation
+
+    gem install rack-session-rethinkdb
+
+The database and table to be used for storage must be created prior to use. The database name must be provided, the table name will default to `sessions` unless an alternate is specified.
+
+## Usage
+
+Sessions will be stored in the table `sessions` by default. The hostname/IP and
+database name must be specified and must exist.
+
+    require 'rack/session/rethinkdb'
+
+    use Rack::Session::RethinkDB, {
+      host:  '127.0.0.1',  # required
+      db:    'myapp',      # required
+      port:  28015,        # optional (default: 28015)
+      table: 'sessions'    # optional (default: 'sessions')
+    }

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'bundler/setup'
+Bundler.require
+require 'rake/clean'
+require 'rubygems/package_task'
+
+load 'tasks/db.rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w(-fs --color)
+end
+
+task default: ['db:reset', :spec]
+
+desc 'Build'
+task build: [:clean, :doc, :gem]
+
+gemspec = Gem::Specification.load('rack-session-rethinkdb.gemspec')
+
+Gem::PackageTask.new(gemspec) do |pkg|
+end
+
+CLEAN.include(['pkg', '*.gem', '.yardoc'])

data/lib/rack/session/rethinkdb.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'rack/session/abstract/id'
+require 'thread'
+require 'rethinkdb'
+
+module Rack
+  module Session
+    class RethinkDB < Abstract::ID
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+                          port: 28_015, table: 'sessions'
+
+      attr_reader :mutex, :pool, :host, :port, :db, :table
+
+      # @see Rack::Session#initialize
+      #
+      # @param [Hash<Symbol,Object>] options
+      # @option options [String] :host hostname or IP for RethinkDB server
+      #                                (required)
+      # @option options [Integer] :port port number for the RethinkDB server
+      #                                 (default: 28015)
+      # @option options [String] :db database name (required)
+      # @option options [String] :table table name to store sessions in
+      #                                 (default: 'sessions')
+      def initialize(app, options = {})
+        super
+        @host  = options[:host]
+        @port  = @default_options[:port]
+        @db    = @default_options[:db]
+        @table = @default_options[:table]
+
+        @mutex = Mutex.new
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless _exists?(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        with_lock(env, [nil, {}]) do
+          unless sid && (session = _get(sid))
+            sid, session = generate_sid, {}
+            _put(sid, session)
+          end
+
+          [sid, session]
+        end
+      end
+
+      def set_session(env, session_id, new_session, _options)
+        with_lock(env, false) do
+          _put(session_id, new_session)
+          session_id
+        end
+      end
+
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          # @pool.del(session_id)
+          ::RethinkDB::RQL.new.db(db).table(table).get(session_id).delete
+            .run(connection)
+          generate_sid unless options[:drop]
+        end
+      end
+
+      def with_lock(env, default = nil)
+        mutex.lock if env['rack.multithread']
+        yield
+      rescue
+        default
+      ensure
+        mutex.unlock if mutex.locked?
+      end
+
+      private
+
+      # @return [RethinkDB::Connection]
+      def connection
+        @connection ||= ::RethinkDB::RQL.new.connect(host: host, port: port)
+      rescue Exception => err
+        $stderr.puts("Cannot connect to database: #{err.message}")
+      end
+
+      # Handle to the RethinkDB::RQL query DSL helper
+      #
+      # @return [RethinkDB::RQL]
+      def r
+        @r ||= ::RethinkDB::RQL.new
+      end
+
+      def _exists?(sid)
+        !_get(sid).nil?
+      end
+
+      def _get(sid)
+        record = r.db(db).table(table).get(sid).run(connection)
+        return unless record
+        Marshal.load(record['data'].unpack('m*').first)
+      end
+
+      def _put(sid, session)
+        data = {
+          id: sid,
+          updated_at: Time.now,
+          data: [Marshal.dump(session)].pack('m*')
+        }
+
+        r.db(db).table(table).insert(data, upsert: true).run(connection)
+      end
+    end
+  end
+end

data/spec/rethinkdb_session_spec.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+require File.expand_path('./spec_helper.rb', File.dirname(__FILE__))
+
+require 'rack/session/rethinkdb'
+require 'rack/mock'
+
+def get_sid(response)
+  /#{session_key}=(.+?)\W/.match(response['Set-Cookie'])[1]
+end
+
+describe Rack::Session::RethinkDB do
+  let(:db_name) { 'rack_session_rethinkdb_test' }
+  let(:config) { { host: '127.0.0.1', port: 28015, db: db_name } }
+  let(:session_key) { Rack::Session::RethinkDB::DEFAULT_OPTIONS[:key] }
+  let(:default_table) { Rack::Session::RethinkDB::DEFAULT_OPTIONS[:table] }
+  let(:session_match) { /#{session_key}=[0-9a-fA-F]+;/ }
+
+  let(:connection) do
+    RethinkDB::RQL.new.connect(host: '127.0.0.1', port: 28015)
+  end
+
+  let!(:incrementor) do
+    lambda do |env|
+      env['rack.session']['counter'] ||= 0
+      env['rack.session']['counter'] += 1
+      Rack::Response.new(env['rack.session'].inspect).to_a
+    end
+  end
+
+  describe 'configuration' do
+    describe 'when :table is specified' do
+      let(:table) { 'my_session_table_test' }
+      let(:pool) do
+        Rack::Session::RethinkDB.new(incrementor, config.merge(table: table))
+      end
+      let(:response) { Rack::MockRequest.new(pool).get('/') }
+      let(:sid) { /#{session_key}=(.+?)\W/.match(response['Set-Cookie'])[1] }
+      let(:record) do
+        RethinkDB::RQL.new.db(db_name).table(table).get(sid).run(connection)
+      end
+
+      it 'writes the session to the named table' do
+        expect(record).to include('id' => sid)
+      end
+    end
+  end
+
+  describe 'when no session cookie is set' do
+    let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+    let(:response) { Rack::MockRequest.new(pool).get('/') }
+
+    it 'sets a cookie' do
+      expect(response['Set-Cookie']).to match(/#{session_key}=.+/)
+    end
+
+    describe 'persistence' do
+      let(:sid) { get_sid(response) }
+      let(:record) do
+        RethinkDB::RQL.new.db(db_name).table(default_table)
+          .get(sid).run(connection)
+      end
+
+      it 'writes a document for the session' do
+        expect(record).to include('id' => sid)
+      end
+
+      it 'persists the session data as a base64 encoded marshalled array' do
+        data = Marshal.load(record['data'].unpack('m*').first)
+
+        expect(data).to include('counter' => 1)
+      end
+
+      it 'sets the updated_at timestamp' do
+        expect(record['updated_at']).to be_a_kind_of(Time)
+        expect(record['updated_at']).to be_within(1).of(Time.now)
+      end
+    end
+  end
+
+  context 'when a session cookie is present' do
+    context 'when the session ID is found in the database' do
+      let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+      let(:request) { Rack::MockRequest.new(pool) }
+      let(:response) do
+        cookie = request.get('/')['Set-Cookie']
+        request.get('/', 'HTTP_COOKIE' => cookie)
+      end
+
+      it 'sets the serialized session data on the request' do
+        expect(response.body).to eq('{"counter"=>2}')
+      end
+
+      it 'does not resend the session id' do
+        expect(response['Set-Cookie']).to be_nil
+      end
+    end
+
+    context 'when the session has expired' do
+    end
+
+    context 'when the session ID is not found in the database' do
+      let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+      let(:request) { Rack::MockRequest.new(pool) }
+      let(:bad_sid) { 'foobarbaz' }
+      let(:response) do
+        request.get('/', 'HTTP_COOKIE' => "#{session_key}=#{bad_sid}")
+      end
+      let(:sid) { get_sid(response) }
+
+      it 'sets up fresh session data' do
+        expect(response.body).to eq('{"counter"=>1}')
+      end
+
+      it 'sets a new session ID' do
+        expect(sid).not_to eq(bad_sid)
+      end
+    end
+  end
+
+  describe 'rack.session.options' do
+    context 'when :drop is set' do
+      let!(:drop_session) do
+        Rack::Lint.new(lambda do |env|
+          env['rack.session.options'][:drop] = true
+          incrementor.call(env)
+        end)
+      end
+      let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+      let(:request) { Rack::MockRequest.new(pool) }
+      let(:drop_request) do
+        Rack::MockRequest.new(Rack::Utils::Context.new(pool, drop_session))
+      end
+
+      it 'deletes cookies with :drop option' do
+        res1 = request.get('/')
+        session = (cookie = res1['Set-Cookie'])[session_match]
+        expect(res1.body).to eq('{"counter"=>1}')
+
+        res2 = drop_request.get('/', 'HTTP_COOKIE' => cookie)
+        expect(res2['Set-Cookie']).to be_nil
+        expect(res2.body).to eq('{"counter"=>2}')
+
+        res3 = request.get('/', 'HTTP_COOKIE' => cookie)
+        expect(res3['Set-Cookie'][session_match]).not_to eq(session)
+        expect(res3.body).to eq('{"counter"=>1}')
+      end
+    end
+
+    context 'when :renew is set' do
+      let!(:renew_session) do
+        Rack::Lint.new(lambda do |env|
+          env['rack.session.options'][:renew] = true
+          incrementor.call(env)
+        end)
+      end
+      let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+      let(:request) { Rack::MockRequest.new(pool) }
+      let(:renew_request) do
+        Rack::MockRequest.new(Rack::Utils::Context.new(pool, renew_session))
+      end
+
+      it 'provides a new session ID' do
+        res1 = request.get('/')
+        session = (cookie = res1['Set-Cookie'])[session_match]
+        expect(res1.body).to eq('{"counter"=>1}')
+
+        res2 = renew_request.get('/', 'HTTP_COOKIE' => cookie)
+        new_cookie = res2['Set-Cookie']
+        new_session = new_cookie[session_match]
+        expect(new_session).not_to eq(session)
+        expect(res2.body).to eq('{"counter"=>2}')
+
+        res3 = request.get('/', 'HTTP_COOKIE' => new_cookie)
+        expect(res3.body).to eq('{"counter"=>3}')
+
+        res4 = request.get('/', 'HTTP_COOKIE' => cookie)
+        expect(res4.body).to eq('{"counter"=>1}')
+      end
+
+      it 'deletes the original session' do
+        res1 = request.get('/')
+        original_sid = get_sid(res1)
+        cookie = res1['Set-Cookie'][session_match]
+        res2 = renew_request.get('/', 'HTTP_COOKIE' => cookie)
+
+        expect(RethinkDB::RQL.new.db(db_name).table(default_table)
+          .get(original_sid).run(connection)).to be_nil
+      end
+    end
+
+    context 'when :defer is set' do
+      let(:pool) { Rack::Session::RethinkDB.new(incrementor, config) }
+      let!(:defer_session) do
+        Rack::Lint.new(lambda do |env|
+          env['rack.session.options'][:defer] = true
+          incrementor.call(env)
+        end)
+      end
+
+      let(:defer_request) do
+        Rack::MockRequest.new(Rack::Utils::Context.new(pool, defer_session))
+      end
+
+      it 'omits the cookie' do
+        res1 = defer_request.get('/')
+        expect(res1['Set-Cookie']).to be_nil
+        expect(res1.body).to eq('{"counter"=>1}')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'bundler/setup'
+Bundler.require
+
+require 'rspec'
+
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: rack-session-rethinkdb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Dlug
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rethinkdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: Provides a rack session middleware to store sessions in a RethinkDB table.
+email: paul.dlug@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/rack/session/rethinkdb.rb
+- spec/rethinkdb_session_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/pdlug/rack-session-rethinkdb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rack session storage in RethinkDB
+test_files: []