couchrest_session_store 0.2.4 → 0.3.0

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p194

data/README.md

@@ -2,16 +2,132 @@
 
 A simple session store based on CouchRest Model.
 
-
 ## Setup ##
 
-CouchRest::Session::Store will automatically pick up the config/couch.yml file for CouchRest Model.
-Cleaning up sessions requires a design document in the sessions database that enables querying by expiry. See the design directory for an example and test/setup_couch.sh for a script that puts the document on the couch for our tests.
+`CouchRest::Session::Store` will automatically pick up the config/couch.yml
+file used by CouchRest Model.
 
+Cleaning up sessions requires a design document in the sessions database that
+enables querying by expiry. See `design/Session.json` for an example. This
+design document is loaded for tests, but you will need to load it on your own
+in a production environment. For example:
 
+    curl -X PUT username:password@localhost:5984/couchrest_sessions/_design/Session --data @design/Session.json
 
 ## Options ##
 
-* marhal_data: (_defaults true_) - if set to false session data will be stored directly in the couch document. Otherwise it's marshalled and base64 encoded to enable restoring ruby data structures.
+* marshal_data: (_defaults true_) - if set to false session data will be stored
+  directly in the couch document. Otherwise it's marshalled and base64 encoded
+  to enable restoring ruby data structures.
 * database: database to use combined with config prefix and suffix
-* exprire_after: livetime of a session in seconds
+* expire_after: lifetime of a session in seconds.
+
+## Dynamic Databases ##
+
+This gem also includes the module `CouchRest::Model::DatabaseMethod`, which
+allow a Model to dynamically choose what database to use.
+
+An example of specifying database dynamically:
+
+    class Token < CouchRest::Model::Base
+      include CouchRest::Model::DatabaseMethod
+
+      use_database_method :database_name
+
+      def self.database_name
+        time = Time.now.utc
+        "tokens_#{time.year}_#{time.month}"
+      end
+    end
+
+A couple notes:
+
+Once you include `CouchRest::Model::DatabaseMethod`, the database is no longer
+automatically created. In this example, you would need to run
+`Token.database.create!` or `Token.database!` in order to create the database.
+
+The symbol passed to `database_method` must match the name of a class method,
+but if there is also an instance method with the same name then this instance
+method will be called when appropriate. To state the obvious, tread lightly:
+there be dragons when generating database names that depend on properties of
+the instance.
+
+## Database Rotation ##
+
+The module `CouchRest::Model::Rotation` can be included in a Model in
+order to use dynamic databases to perform database rotation.
+
+CouchDB is not good for ephemeral data because old documents are never really
+deleted: when you deleted a document, it just appends a new revision. The bulk
+of the old data is not stored, but it does store a record for each doc id and
+revision id for the document. In the case of ephemeral data, like tokens,
+sessions, or statistics, this will quickly bloat the database with a ton of
+useless deleted documents. The proper solution is to rotate the databases:
+create a new one regularly and delete the old one entirely. This will allow
+you to recover the storage space.
+
+A better solution might be to just use a different database for all
+ephemeral data, like MariaDB or Redis. But, if you really want to use CouchDB, this
+is how you can do it.
+
+An example of specifying database rotation:
+
+    class Token < CouchRest::Model::Base
+      include CouchRest::Model::Rotation
+
+      rotate_database 'tokens', :every => 30.days
+    end
+
+Then, in a task triggered by a cron job:
+
+    CouchRest::Model::Base.configure do |conf|
+      conf.environment = Rails.env
+      conf.connection_config_file = File.join(Rails.root, 'config', 'couchdb.admin.yml')
+    end
+    Token.rotate_database_now(:window => 1.day)
+
+Or perhaps:
+
+    Rails.application.eager_load!
+    CouchRest::Model::Rotation.descendants.each do |model|
+      model.rotate_database_now
+    end
+
+The `:window` argument to `rotate_database_now` specifies how far in advance we
+should create the new database (default 1.day). For ideal behavior, this value
+should be GREATER than or equal to the frequency with which the cron job is
+run. For example, if the cron job is run every hour, the argument can be
+`1.hour`, `2.hours`, `1.day`, but not `20.minutes`.
+
+The method `rotate_database_now` will do nothing if the database has already
+been rotated. Otherwise, as needed, it will create the new database, create
+the design documents, set up replication between the old and new databases,
+and delete the old database (once it is not used anymore).
+
+These actions will require admin access, so if your application normally runs
+without admin rights you will need specify a different configuration for
+CouchRest::Model before `rotate_database_now` is called.
+
+Known issues:
+
+* If you change the rotation period, there will be a break in the rotation
+  (old documents will not get replicated to the new rotated db) and the old db
+  will not get automatically deleted.
+
+* Calling `Model.database.delete!` will not necessarily remove all the
+  relevant databases because of the way prior and future databases are kept
+  for the 'window' period.
+
+## Changes ##
+
+0.3.0
+
+* Added support for dynamic and rotating databases.
+
+0.2.4
+
+* Do not crash if can't connect to CouchDB
+
+0.2.3
+
+* Better retry and conflict catching.d

data/couchrest_session_store.gemspec

@@ -14,11 +14,11 @@ Gem::Specification.new do |gem|
   gem.files = `git ls-files`.split("\n")
   gem.name = "couchrest_session_store"
   gem.require_paths = ["lib"]
-  gem.version = '0.2.4'
+  gem.version = '0.3.0'
 
   gem.add_dependency "couchrest"
   gem.add_dependency "couchrest_model"
-  gem.add_dependency "actionpack"
+  gem.add_dependency "actionpack", '~> 3.0'
 
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "rake"

data/lib/couchrest/model/database_method.rb

@@ -0,0 +1,131 @@
+#
+# Allow setting the database to happen dynamically.
+#
+# Unlike normal CouchRest::Model, the database is not automatically created
+# unless you call database!()
+#
+# The method specified by `database_method` must exist as a class method but
+# may optionally also exist as an instance method.
+#
+
+module CouchRest
+  module Model
+    module DatabaseMethod
+      extend ActiveSupport::Concern
+
+      def database
+        if self.class.database_method
+          self.class.server.database(call_database_method)
+        else
+          self.class.database
+        end
+      end
+
+      def database!
+        if self.class.database_method
+          self.class.server.database!(call_database_method)
+        else
+          self.class.database!
+        end
+      end
+
+      def database_exists?(db_name)
+        self.class.database_exists?(db_name)
+      end
+
+      #
+      # The normal CouchRest::Model::Base comparison checks if the model's
+      # database objects are the same. That is not good for use here, since
+      # the objects will always be different. Instead, we compare the string
+      # that each database evaluates to.
+      #
+      def ==(other)
+        return false unless other.is_a?(Base)
+        if id.nil? && other.id.nil?
+          to_hash == other.to_hash
+        else
+          id == other.id && database.to_s == other.database.to_s
+        end
+      end
+      alias :eql? :==
+
+      protected
+
+      def call_database_method
+        if self.respond_to?(self.class.database_method)
+          name = self.send(self.class.database_method)
+          self.class.db_name_with_prefix(name)
+        else
+          self.class.send(:call_database_method)
+        end
+      end
+
+      module ClassMethods
+
+        def database_method(method = nil)
+          if method
+            @database_method = method
+          end
+          @database_method
+        end
+        alias :use_database_method :database_method
+
+        def database
+          if database_method
+            if !self.respond_to?(database_method)
+              raise ArgumentError.new("Incorrect argument to database_method(): no such method '#{method}' found in class #{self}.")
+            end
+            self.server.database(call_database_method)
+          else
+            @database ||= prepare_database(super)
+          end
+        end
+
+        def database!
+          if database_method
+            self.server.database!(call_database_method)
+          else
+            @database ||= prepare_database(super)
+          end
+        end
+
+        #
+        # same as database(), but allows for an argument that gets passed through to
+        # database method.
+        #
+        def choose_database(*args)
+          self.server.database(call_database_method(*args))
+        end
+
+        def db_name_with_prefix(name)
+          conf = self.send(:connection_configuration)
+          [conf[:prefix], name, conf[:suffix]].reject{|i|i.to_s.empty?}.join(conf[:join])
+        end
+
+        def database_exists?(name)
+          name = db_name_with_prefix(name)
+          begin
+            CouchRest.head "#{self.server.uri}/#{name}"
+            return true
+          rescue RestClient::ResourceNotFound
+            return false
+          end
+        end
+
+        protected
+
+        def call_database_method(*args)
+          name = nil
+          method = self.method(database_method)
+          if method.arity == 0
+            name = method.call
+          else
+            name = method.call(*args)
+          end
+          db_name_with_prefix(name)
+        end
+
+      end
+    end
+  end
+end

data/lib/couchrest/model/rotation.rb

@@ -0,0 +1,263 @@
+module CouchRest
+  module Model
+    module Rotation
+      extend ActiveSupport::Concern
+      include CouchRest::Model::DatabaseMethod
+
+      included do
+        use_database_method :rotated_database_name
+      end
+
+      def create(*args)
+        super(*args)
+      rescue RestClient::ResourceNotFound => exc
+        raise storage_missing(exc)
+      end
+
+      def update(*args)
+        super(*args)
+      rescue RestClient::ResourceNotFound => exc
+        raise storage_missing(exc)
+      end
+
+      def destroy(*args)
+        super(*args)
+      rescue RestClient::ResourceNotFound => exc
+        raise storage_missing(exc)
+      end
+
+      private
+
+      # returns a special 'storage missing' exception when the db has
+      # not been created. very useful, since this happens a lot and a
+      # generic 404 is not that helpful.
+      def storage_missing(exc)
+        if exc.http_body =~ /no_db_file/
+          CouchRest::StorageMissing.new(exc.response, database)
+        else
+          exc
+        end
+      end
+
+      public
+
+      module ClassMethods
+        #
+        # Set up database rotation.
+        #
+        # base_name -- the name of the db before the rotation number is
+        # appended.
+        #
+        # options -- one of:
+        #
+        # * :every -- frequency of rotation
+        # * :expiration_field - what field to use to determine if a
+        #                       document is expired.
+        # * :timestamp_field - alternately, what field to use for the
+        #                      document timestamp.
+        # * :timeout -- used to expire documents with only a timestamp
+        #               field (in minutes)
+        #
+        def rotate_database(base_name, options={})
+          @rotation_base_name = base_name
+          @rotation_every = (options.delete(:every) || 30.days).to_i
+          @expiration_field = options.delete(:expiration_field)
+          @timestamp_field = options.delete(:timestamp_field)
+          @timeout = options.delete(:timeout)
+          if options.any?
+            raise ArgumentError.new('Could not understand options %s' % options.keys)
+          end
+        end
+
+        #
+        # Check to see if dbs should be rotated. The :window
+        # argument specifies how far in advance we should
+        # create the new database (default 1.day).
+        #
+        # This method relies on the assumption that it is called
+        # at least once within each @rotation_every period.
+        #
+        def rotate_database_now(options={})
+          window = options[:window] || 1.day
+
+          now = Time.now.utc
+          current_name = rotated_database_name(now)
+          current_count = now.to_i/@rotation_every
+
+          next_time = window.from_now.utc
+          next_name = rotated_database_name(next_time)
+          next_count = current_count+1
+
+          prev_name = current_name.sub(/(\d+)$/) {|i| i.to_i-1}
+          replication_started = false
+          old_name = prev_name.sub(/(\d+)$/) {|i| i.to_i-1} # even older than prev_name
+          trailing_edge_time = window.ago.utc
+
+          if !database_exists?(current_name)
+            # we should have created the current db earlier, but if somehow
+            # it is missing we must make sure it exists.
+            create_new_rotated_database(:from => prev_name, :to => current_name)
+            replication_started = true
+          end
+
+          if next_time.to_i/@rotation_every >= next_count && !database_exists?(next_name)
+            # time to create the next db in advance of actually needing it.
+            create_new_rotated_database(:from => current_name, :to => next_name)
+          end
+
+          if trailing_edge_time.to_i/@rotation_every == current_count
+            # delete old dbs, but only after window time has past since the last rotation
+            if !replication_started && database_exists?(prev_name)
+              # delete previous, but only if we didn't just start replicating from it
+              self.server.database(db_name_with_prefix(prev_name)).delete!
+            end
+            if database_exists?(old_name)
+              # there are some edge cases, when rotate_database_now is run
+              # infrequently, that an older db might be left around.
+              self.server.database(db_name_with_prefix(old_name)).delete!
+            end
+          end
+        end
+
+        def rotated_database_name(time=nil)
+          unless @rotation_base_name && @rotation_every
+            raise ArgumentError.new('missing @rotation_base_name or @rotation_every')
+          end
+          time ||= Time.now.utc
+          units = time.to_i / @rotation_every.to_i
+          "#{@rotation_base_name}_#{units}"
+        end
+
+        #
+        # create a new empty database.
+        #
+        def create_database!(name=nil)
+          db = if name
+            self.server.database!(db_name_with_prefix(name))
+          else
+            self.database!
+          end
+          create_rotation_filter(db)
+          if self.respond_to?(:design_doc)
+            design_doc.sync!(db)
+            # or maybe this?:
+            #self.design_docs.each do |design|
+            #  design.migrate(to_db)
+            #end
+          end
+          return db
+        end
+
+        protected
+
+        #
+        # Creates database named by options[:to]. Optionally, set up
+        # continuous replication from the options[:from] db, if it exists. The
+        # assumption is that the from db will be destroyed later, cleaning up
+        # the replication once it is no longer needed.
+        #
+        # This method will also copy design documents if present in the from
+        # db, in the CouchRest::Model, or in a database named after
+        # @rotation_base_name.
+        #
+        def create_new_rotated_database(options={})
+          from = options[:from]
+          to = options[:to]
+          to_db = self.create_database!(to)
+          if database_exists?(@rotation_base_name)
+            base_db = self.server.database(db_name_with_prefix(@rotation_base_name))
+            copy_design_docs(base_db, to_db)
+          end
+          if from && from != to && database_exists?(from)
+            from_db = self.server.database(db_name_with_prefix(from))
+            replicate_old_to_new(from_db, to_db)
+          end
+        end
+
+        def copy_design_docs(from, to)
+          params = {:startkey => '_design/', :endkey => '_design0', :include_docs => true}
+          from.documents(params) do |doc_hash|
+            design = doc_hash['doc']
+            begin
+              to.get(design['_id'])
+            rescue RestClient::ResourceNotFound
+              design.delete('_rev')
+              to.save_doc(design)
+            end
+          end
+        end
+
+        def create_rotation_filter(db)
+          name = 'rotation_filter'
+          filter_string = if @expiration_field
+            NOT_EXPIRED_FILTER % {:expires => @expiration_field}
+          elsif @timestamp_field && @timeout
+            NOT_TIMED_OUT_FILTER % {:timestamp => @timestamp_field, :timeout => (60 * @timeout)}
+          else
+            NOT_DELETED_FILTER
+          end
+          filters = {"not_expired" => filter_string}
+          db.save_doc("_id" => "_design/#{name}", "filters" => filters)
+        rescue RestClient::Conflict
+        end
+
+        #
+        # Replicates documents from_db to to_db, skipping documents that have
+        # expired or been deleted.
+        #
+        # NOTE: It would be better if we could do this:
+        #
+        #   from_db.replicate_to(to_db, true, false,
+        #     :filter => 'rotation_filter/not_expired')
+        #
+        # But replicate_to() does not support a filter argument, so we call
+        # the private method replication() directly.
+        #
+        def replicate_old_to_new(from_db, to_db)
+          create_rotation_filter(from_db)
+          from_db.send(:replicate, to_db, true, :source => from_db.name, :filter => 'rotation_filter/not_expired')
+        end
+
+        #
+        # Three different filters, depending on how the model is set up.
+        #
+        # NOT_EXPIRED_FILTER is used when there is a single field that
+        # contains an absolute time for when the document has expired. The
+        #
+        # NOT_TIMED_OUT_FILTER is used when there is a field that records the
+        # timestamp of the last time the document was used. The expiration in
+        # this case is calculated from the timestamp plus @timeout.
+        #
+        # NOT_DELETED_FILTER is used when the other two cannot be.
+        #
+        NOT_EXPIRED_FILTER = "" +
+%[function(doc, req) {
+  if (doc._deleted) {
+    return false;
+  } else if (typeof(doc.%{expires}) != "undefined") {
+    return Date.now() < (new Date(doc.%{expires})).getTime();
+  } else {
+    return true;
+  }
+}]
+
+        NOT_TIMED_OUT_FILTER = "" +
+%[function(doc, req) {
+  if (doc._deleted) {
+    return false;
+  } else if (typeof(doc.%{timestamp}) != "undefined") {
+    return Date.now() < (new Date(doc.%{timestamp})).getTime() + %{timeout};
+  } else {
+    return true;
+  }
+}]
+
+        NOT_DELETED_FILTER = "" +
+%[function(doc, req) {
+  return !doc._deleted;
+}]
+
+      end
+    end
+  end
+end

data/lib/couchrest/session.rb

@@ -1,4 +1,14 @@
 module CouchRest
+
+  class StorageMissing < RestClient::Exception
+    attr_reader :db
+    def initialize(request, db)
+      super(request)
+      @db = db.name
+      @message = "The database '#{db}' does not exist."
+    end
+  end
+
   module Session
   end
 end

data/lib/couchrest/session/document.rb

@@ -5,8 +5,10 @@ class CouchRest::Session::Document < CouchRest::Document
   include CouchRest::Model::Configuration
   include CouchRest::Model::Connection
   include CouchRest::Session::Utility
+  include CouchRest::Model::Rotation
 
-  use_database "sessions"
+  rotate_database 'sessions',
+    :every => 1.month, :expiration_field => :expires
 
   def self.fetch(sid)
     self.allocate.tap do |session_doc|
@@ -36,6 +38,18 @@ class CouchRest::Session::Document < CouchRest::Document
     response['rows']
   end
 
+  def self.create_database!(name=nil)
+    db = super(name)
+    begin
+      db.get('_design/Session')
+    rescue RestClient::ResourceNotFound
+      design = File.read(File.expand_path('../../../../design/Session.json', __FILE__))
+      design = JSON.parse(design)
+      db.save_doc(design.merge({"_id" => "_design/Session"}))
+    end
+    db
+  end
+
   def initialize(doc)
     @doc = doc
   end
@@ -70,6 +84,11 @@ class CouchRest::Session::Document < CouchRest::Document
   rescue RestClient::Conflict
     fetch
     retry
+  rescue RestClient::ResourceNotFound => exc
+    if exc.http_body =~ /no_db_file/
+      exc = CouchRest::StorageMissing.new(exc.response, database)
+    end
+    raise exc
   end
 
   def expired?

data/lib/couchrest_session_store.rb

@@ -4,7 +4,8 @@ require 'couchrest_model'
 gem 'actionpack', '~> 3.0'
 require 'action_dispatch'
 
+require 'couchrest/model/database_method'
+require 'couchrest/model/rotation'
 require 'couchrest/session'
 require 'couchrest/session/store'
 require 'couchrest/session/document'
-

data/test/couch_tester.rb

@@ -6,13 +6,12 @@
 class CouchTester < CouchRest::Document
   include CouchRest::Model::Configuration
   include CouchRest::Model::Connection
+  include CouchRest::Model::Rotation
 
-  use_database 'sessions'
+  rotate_database 'sessions',
+    :every => 1.month, :expiration_field => :expires
 
   def initialize(options = {})
-    if options[:database]
-      self.class.use_database options[:database]
-    end
   end
 
   def get(sid)

data/test/database_method_test.rb

@@ -0,0 +1,116 @@
+require_relative 'test_helper'
+
+class DatabaseMethodTest < MiniTest::Test
+
+  class TestModel < CouchRest::Model::Base
+    include CouchRest::Model::DatabaseMethod
+
+    use_database_method :db_name
+    property :dbname, String
+    property :confirm, String
+
+    def db_name
+      "test_db_#{self[:dbname]}"
+    end
+  end
+
+  def test_instance_method
+    doc1 = TestModel.new({:dbname => 'one'})
+    doc1.database.create!
+    assert doc1.database.root.ends_with?('test_db_one')
+    assert doc1.save
+    doc1.update_attributes(:confirm => 'yep')
+
+    doc2 = TestModel.new({:dbname => 'two'})
+    doc2.database.create!
+    assert doc2.database.root.ends_with?('test_db_two')
+    assert doc2.save
+    doc2.confirm = 'sure'
+    doc2.save!
+
+    doc1_copy = CouchRest.get([doc1.database.root, doc1.id].join('/'))
+    assert_equal "yep", doc1_copy["confirm"]
+
+    doc2_copy = CouchRest.get([doc2.database.root, doc2.id].join('/'))
+    assert_equal "sure", doc2_copy["confirm"]
+
+    doc1.database.delete!
+    doc2.database.delete!
+  end
+
+  def test_switch_db
+    doc_red = TestModel.new({:dbname => 'red', :confirm => 'rose'})
+    doc_red.database.create!
+    root = doc_red.database.root
+
+    doc_blue = doc_red.clone
+    doc_blue.dbname = 'blue'
+    doc_blue.database!
+    doc_blue.save!
+
+    doc_blue_copy = CouchRest.get([root.sub('red','blue'), doc_blue.id].join('/'))
+    assert_equal "rose", doc_blue_copy["confirm"]
+
+    doc_red.database.delete!
+    doc_blue.database.delete!
+  end
+
+  #
+  # A test scenario for database_method in which some user accounts
+  # are stored in a seperate temporary database (so that the test
+  # accounts don't bloat the normal database).
+  #
+
+  class User < CouchRest::Model::Base
+    include CouchRest::Model::DatabaseMethod
+
+    use_database_method :db_name
+    property :login, String
+    before_save :create_db
+
+    class << self
+      def get(id, db = database)
+        result = super(id, db)
+        if result.nil?
+          return super(id, choose_database('test-user'))
+        else
+          return result
+        end
+      end
+      alias :find :get
+    end
+
+    protected
+
+    def self.db_name(login = nil)
+      if !login.nil? && login =~ /test-user/
+        'tmp_users'
+      else
+        'users'
+      end
+    end
+
+    def db_name
+      self.class.db_name(self.login)
+    end
+
+    def create_db
+      unless database_exists?(db_name)
+        self.database!
+      end
+    end
+
+  end
+
+  def test_tmp_user_db
+    user1 = User.new({:login => 'test-user-1'})
+    assert user1.save
+    assert User.find(user1.id), 'should find user in tmp_users'
+    assert_equal user1.login, User.find(user1.id).login
+    assert_equal 'test-user-1', User.server.database('couchrest_tmp_users').get(user1.id)['login']
+    assert_raises RestClient::ResourceNotFound do
+      User.server.database('couchrest_users').get(user1.id)
+    end
+  end
+
+end

data/test/database_rotation_test.rb

@@ -0,0 +1,88 @@
+require_relative 'test_helper'
+
+class RotationTest < MiniTest::Test
+
+  class Token < CouchRest::Model::Base
+    include CouchRest::Model::Rotation
+    property :token, String
+    rotate_database 'test_rotate', :every => 1.day
+  end
+
+  TEST_DB_RE = /test_rotate_\d+/
+
+  def test_rotate
+    delete_all_dbs
+    doc = nil
+    original_name = nil
+    next_db_name = nil
+
+    Time.stub :now, Time.gm(2015,3,7,0) do
+      Token.create_database!
+      doc = Token.create!(:token => 'aaaa')
+      original_name = Token.rotated_database_name
+      assert database_exists?(original_name)
+      assert_equal 1, count_dbs
+    end
+
+    # do nothing yet
+    Time.stub :now, Time.gm(2015,3,7,22) do
+      Token.rotate_database_now(:window => 1.hour)
+      assert_equal original_name, Token.rotated_database_name
+      assert_equal 1, count_dbs
+    end
+
+    # create next db, but don't switch yet.
+    Time.stub :now, Time.gm(2015,3,7,23) do
+      Token.rotate_database_now(:window => 1.hour)
+      assert_equal 2, count_dbs
+      next_db_name = Token.rotated_database_name(Time.gm(2015,3,8))
+      assert original_name != next_db_name
+      assert database_exists?(next_db_name)
+      sleep 0.2 # allow time for documents to replicate
+      assert_equal(
+        Token.get(doc.id).token,
+        Token.get(doc.id, database(next_db_name)).token
+      )
+    end
+
+    # use next db
+    Time.stub :now, Time.gm(2015,3,8) do
+      Token.rotate_database_now(:window => 1.hour)
+      assert_equal 2, count_dbs
+      assert_equal next_db_name, Token.rotated_database_name
+      token = Token.get(doc.id)
+      token.update_attributes(:token => 'bbbb')
+      assert_equal 'bbbb', Token.get(doc.id).token
+      assert_equal 'aaaa', Token.get(doc.id, database(original_name)).token
+    end
+
+    # delete prior db
+    Time.stub :now, Time.gm(2015,3,8,1) do
+      Token.rotate_database_now(:window => 1.hour)
+      assert_equal 1, count_dbs
+    end
+  end
+
+  private
+
+  def database(db_name)
+    Token.server.database(Token.db_name_with_prefix(db_name))
+  end
+
+  def database_exists?(dbname)
+    Token.database_exists?(dbname)
+  end
+
+  def delete_all_dbs(regexp=TEST_DB_RE)
+    Token.server.databases.each do |db|
+      if regexp.match(db)
+        Token.server.database(db).delete!
+      end
+    end
+  end
+
+  def count_dbs(regexp=TEST_DB_RE)
+    Token.server.databases.grep(regexp).count
+  end
+
+end

data/test/stress_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+#
+# This doesn't really test much, but is useful if you want to see what happens
+# when you have a lot of documents.
+#
+
+class StressTest < MiniTest::Test
+
+  COUNT = 200 # change to 200,000 if you dare
+
+  class Stress < CouchRest::Model::Base
+    include CouchRest::Model::Rotation
+    property :token, String
+    property :expires_at, Time
+    rotate_database 'stress_test', :every => 1.day, :expiration_field => :expires_at
+  end
+
+  def test_stress
+    delete_all_dbs /^couchrest_stress_test_\d+$/
+
+    Stress.database!
+    COUNT.times do |i|
+      doc = Stress.create!(:token => SecureRandom.hex(32), :expires_at => expires(i))
+    end
+
+    Time.stub :now, 1.day.from_now do
+      Stress.rotate_database_now(:window => 1.hour)
+      sleep 0.5
+      assert_equal (COUNT/100)+1, Stress.database.info["doc_count"]
+    end
+  end
+
+  private
+
+  def delete_all_dbs(regexp=TEST_DB_RE)
+    Stress.server.databases.each do |db|
+      if regexp.match(db)
+        Stress.server.database(db).delete!
+      end
+    end
+  end
+
+  def expires(i)
+    if i % 100 == 0
+      1.hour.from_now.utc
+    else
+      1.hour.ago.utc
+    end
+  end
+end

data/test/test_helper.rb

@@ -4,3 +4,6 @@ require 'minitest/autorun'
 require File.expand_path(File.dirname(__FILE__) + '/../lib/couchrest_session_store.rb')
 require File.expand_path(File.dirname(__FILE__) + '/couch_tester.rb')
 require File.expand_path(File.dirname(__FILE__) + '/test_clock.rb')
+
+# Create the session db if it does not already exist.
+CouchRest::Session::Document.create_database!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: couchrest_session_store
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-13 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest
@@ -48,17 +48,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -98,21 +98,27 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .ruby-version
 - .travis.yml
 - Gemfile
 - README.md
 - Rakefile
 - couchrest_session_store.gemspec
 - design/Session.json
+- lib/couchrest/model/database_method.rb
+- lib/couchrest/model/rotation.rb
 - lib/couchrest/session.rb
 - lib/couchrest/session/document.rb
 - lib/couchrest/session/store.rb
 - lib/couchrest/session/utility.rb
 - lib/couchrest_session_store.rb
 - test/couch_tester.rb
+- test/database_method_test.rb
+- test/database_rotation_test.rb
 - test/session_document_test.rb
 - test/session_store_test.rb
 - test/setup_couch.sh
+- test/stress_test.rb
 - test/test_clock.rb
 - test/test_helper.rb
 homepage: http://github.com/azul/couchrest_session_store
@@ -135,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A Rails Session Store based on CouchRest Model