mongo-lock 1.1.4 → 1.2.0

data/lib/mongo-lock/drivers/base.rb

@@ -0,0 +1,41 @@
+module Mongo
+  class Lock
+    module Drivers
+      class Base
+
+        attr_accessor :lock
+
+        def initialize lock
+          self.lock = lock
+        end
+
+        def key
+          lock.key
+        end
+
+        def query
+          {
+            key: key,
+            expires_at: { '$gt' => Time.now }
+          }
+        end
+
+        def find_or_insert options
+          options[:expire_at] = Time.now + options[:expire_in]
+          options[:insert] = true
+          find_and_modify options
+        end
+
+        def find_and_update time, options
+          options[:expire_at] = lock.expires_at + time
+          find_and_modify options
+        end
+
+        def is_acquired?
+          find_already_acquired.count > 0
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo-lock/drivers/mongo.rb

@@ -0,0 +1,99 @@
+module Mongo
+  class Lock
+    module Drivers
+      class Mongo < Base
+
+        attr_accessor :lock
+
+        def self.release_collection collection, owner=nil
+          selector = if owner then { owner: owner } else {} end
+          collection.remove(selector)
+        end
+
+        def self.ensure_indexes collection
+          collection.create_index([
+            ['key', ::Mongo::ASCENDING],
+            ['owner', ::Mongo::ASCENDING],
+            ['expires_at', ::Mongo::ASCENDING]
+          ])
+          collection.create_index([['ttl', ::Mongo::ASCENDING]],{ expireAfterSeconds: 0 })
+        end
+
+        def self.clear_expired collection
+          collection.remove expires_at: { '$lt' => Time.now }
+        end
+
+        def initialize lock
+          self.lock = lock
+        end
+
+        def key
+          lock.key
+        end
+
+        def query
+          {
+            key: key,
+            expires_at: { '$gt' => Time.now }
+          }
+        end
+
+        def find_or_insert options
+          options[:expire_at] = Time.now + options[:expire_in]
+          options[:insert] = true
+          find_and_modify options
+        end
+
+        def find_and_update time, options
+          options[:expire_at] = lock.expires_at + time
+          find_and_modify options
+        end
+
+        def find_and_modify options
+          operation = options[:insert] ? '$setOnInsert' : '$set'
+          existing_lock = lock.configuration.collection.find_and_modify({
+            query: query,
+            update: {
+              operation => {
+                key: key,
+                owner: options[:owner],
+                expires_at: options[:expire_at],
+                ttl: options[:expire_at]
+              }
+            },
+            upsert: !!options[:insert]
+          })
+
+          if existing_lock
+            lock.expires_at = existing_lock['expires_at']
+          else
+            lock.expires_at = options[:expire_at]
+          end
+
+          existing_lock
+        end
+
+        def remove options
+          lock.configuration.collection.remove key: key, owner: options[:owner]
+        end
+
+        def is_acquired?
+          find_already_acquired.count > 0
+        end
+
+        def find_already_acquired
+          lock.configuration.collection.find({
+            key: key,
+            owner: lock.configuration.owner,
+            expires_at: { '$gt' => Time.now }
+          })
+        end
+
+        def find_existing
+          lock.configuration.collection.find(query).first
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo-lock/drivers/moped.rb

@@ -0,0 +1,62 @@
+module Mongo
+  class Lock
+    module Drivers
+      class Moped < Base
+
+        def self.release_collection collection, owner=nil
+          selector = if owner then { owner: owner } else {} end
+          collection.find(selector).remove_all
+        end
+
+        def self.ensure_indexes collection
+          collection.indexes.create({ key: 1, owner: 1, expires_at: 1 })
+          collection.indexes.create({ ttl: 1 }, { expireAfterSeconds: 0 })
+        end
+
+        def self.clear_expired collection
+          collection.find(expires_at: { '$lt' => Time.now }).remove_all
+        end
+
+        def find_and_modify options
+          operation = options[:insert] ? '$setOnInsert' : '$set'
+          existing_lock = lock.configuration.collection.
+            find(query).
+            modify({
+              operation => {
+                key: key,
+                owner: options[:owner],
+                expires_at: options[:expire_at],
+                ttl: options[:expire_at]
+              }
+            }, { upsert: !!options[:insert] })
+          existing_lock = nil if existing_lock == {} # Moped returns {} for an empty result
+
+          if existing_lock
+            lock.expires_at = existing_lock['expires_at']
+          else
+            lock.expires_at = options[:expire_at]
+          end
+
+          existing_lock
+        end
+
+        def remove options
+          lock.configuration.collection.find( key: key, owner: options[:owner] ).remove_all
+        end
+
+        def find_already_acquired
+          lock.configuration.collection.find({
+            key: key,
+            owner: lock.configuration.owner,
+            expires_at: { '$gt' => Time.now }
+          })
+        end
+
+        def find_existing
+          lock.configuration.collection.find(query).first
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo-lock/send_with_raise_methods.rb

@@ -0,0 +1,28 @@
+module Mongo
+  class Lock
+    module SendWithRaiseMethods
+
+      def send_with_raise method, *args
+        args.last[:should_raise] = true
+        self.send(method, *args)
+      end
+
+      def acquire! options = {}
+        send_with_raise :acquire, options
+      end
+
+      def release! options = {}
+        send_with_raise :release, options
+      end
+
+      def extend_by! time, options = {}
+        send_with_raise :extend_by, time, options
+      end
+
+      def extend! options = {}
+        send_with_raise :extend, options
+      end
+
+    end
+  end
+end

data/lib/mongo-lock/version.rb

@@ -1,5 +1,5 @@
 module Mongo
   class Lock
-    VERSION = "1.1.4"
+    VERSION = "1.2.0"
   end
 end

data/mongo-lock.gemspec

@@ -22,13 +22,14 @@ Gem::Specification.new do |spec|
   # s.add_dependency 'some-gem'
   spec.extra_rdoc_files = ['README.md', 'LICENSE']
 
-  spec.add_dependency 'mongo'
-
+  spec.add_development_dependency 'mongo'
+  spec.add_development_dependency 'moped'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'fuubar'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'activesupport'
   spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'bson_ext'
+  spec.add_development_dependency 'rails', '~> 4.0.0'
 
 end

data/spec/configuration_spec.rb

@@ -63,6 +63,23 @@ describe Mongo::Lock::Configuration do
       expect(subject.instance_variable_get('@collections')).to be collections
     end
 
+    context "when collections are mixed" do
+
+      it "raises an error" do
+        expect{subject.collections = [my_collection, my_moped_collection]}.to raise_error(Mongo::Lock::MixedCollectionsError, "Collections must be of the same class")
+      end
+
+    end
+
+    context "when collections are Moped it" do
+
+      it "chooses the correct driver" do
+        subject.collections = [my_moped_collection]
+        expect(subject.driver).to eql Mongo::Lock::Drivers::Moped
+      end
+
+    end
+
   end
 
   describe "#set_collections_keep_default" do
@@ -91,6 +108,23 @@ describe Mongo::Lock::Configuration do
       expect(subject.instance_variable_get('@collections')[:default]).to be my_collection
     end
 
+    context "when collections are Moped it" do
+
+      it "chooses the correct driver" do
+        subject.collection = my_moped_collection
+        expect(subject.driver).to eql Mongo::Lock::Drivers::Moped
+      end
+
+    end
+
+    context "when collection is not a valid class" do
+
+      it "raises an error" do
+        expect{subject.collection = Object.new}.to raise_error(Mongo::Lock::InvalidCollectionError, "Object is not a valid collection class")
+      end
+
+    end
+
   end
 
   describe "#collection" do
@@ -235,4 +269,36 @@ describe Mongo::Lock::Configuration do
 
   end
 
+  describe "#driver=" do
+
+    context "when given a string" do
+
+      it "should set convert the value into a driver class" do
+        subject.driver = 'moped'
+        expect(subject.instance_variable_get('@driver')).to eql Mongo::Lock::Drivers::Moped
+      end
+
+    end
+
+    context "when given a class" do
+
+      it "should set the driver value" do
+        subject.driver = Mongo::Lock::Drivers::Moped
+        expect(subject.instance_variable_get('@driver')).to eql Mongo::Lock::Drivers::Moped
+      end
+
+    end
+
+  end
+
+  describe "#driver" do
+
+    it "should return the driver value" do
+      subject.instance_variable_set('@driver', Mongo::Lock::Drivers::Moped)
+      expect(subject.driver).to eql Mongo::Lock::Drivers::Moped
+    end
+
+
+  end
+
 end

data/spec/configure_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 
 describe Mongo::Lock do
 
+  configure_for_mongo
+
   describe '.configure' do
 
     after :each do
@@ -52,8 +54,12 @@ describe Mongo::Lock do
         expect(Mongo::Lock.configuration.owner).to eql "#{`hostname`.strip}:#{Process.pid}:#{Thread.object_id}"
       end
 
-      it "sets default raise" do
-        expect(Mongo::Lock.configuration.raise).to be_false
+      it "sets default should_raise" do
+        expect(Mongo::Lock.configuration.should_raise).to be_false
+      end
+
+      it "sets default driver" do
+        expect(Mongo::Lock.configuration.driver).to eql Mongo::Lock::Drivers::Mongo
       end
 
     end

data/spec/examples/acquire_example.rb

@@ -0,0 +1,219 @@
+shared_examples "MongoLock driver that can aquire locks" do
+
+  describe Mongo::Lock do
+
+    describe '.acquire' do
+
+      it "creates and returns a new Mongo::Lock instance" do
+        expect(Mongo::Lock.acquire 'my_lock').to be_a Mongo::Lock
+      end
+
+      it "calls #acquire to acquire the lock" do
+        expect_any_instance_of(Mongo::Lock).to receive(:acquire)
+        Mongo::Lock.acquire 'my_lock'
+      end
+
+      context "when options are provided" do
+
+        it "passes them to the new lock" do
+          lock = Mongo::Lock.acquire('my_lock', { limit: 3 })
+          expect(lock.configuration.limit).to be 3
+        end
+
+      end
+
+      context "when a block is provided" do
+
+        it "passes it to the new lock" do
+          block = Proc.new { |lock| }
+          expect_any_instance_of(Mongo::Lock).to receive(:acquire).with( &block)
+          lock = Mongo::Lock.acquire('my_lock', { limit: 3 }, &block)
+        end
+
+      end
+
+    end
+
+    describe '#acquire' do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence' }
+
+      context "when lock is available" do
+
+        it "acquires the lock" do
+          lock.acquire
+          expect(my_collection.find(key: 'my_lock').count).to be 1
+        end
+
+        it "sets the lock to expire" do
+          lock.acquire
+          expect(my_collection.find(key: 'my_lock').first['expires_at']).to be_within(1.second).of(10.seconds.from_now)
+          expect(my_collection.find(key: 'my_lock').first['ttl']).to be_within(1.second).of(10.seconds.from_now)
+        end
+
+        it "returns true" do
+          expect(lock.acquire).to be_true
+        end
+
+      end
+
+      context "when the frequency option is a Proc" do
+
+        let(:lock) { Mongo::Lock.new 'my_lock' }
+
+        it "should call the Proc with the attempt number" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 10.seconds.from_now
+          proc = Proc.new{ |x| x }
+          expect(proc).to receive(:call).with(1).and_return(0.01)
+          expect(proc).to receive(:call).with(2).and_return(0.01)
+          expect(proc).to receive(:call).with(3).and_return(0.01)
+          lock.acquire limit: 3, frequency: proc
+        end
+
+      end
+
+      context "when the lock is unavailable" do
+
+        it "retries until it can acquire it" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.1.seconds.from_now
+          lock.acquire frequency: 0.01, timeout_in: 0.2, limit: 20
+          expect(my_collection.find(key: 'my_lock', owner: 'spence').count).to be 1
+        end
+
+      end
+
+      context "when the lock is already acquired but by the same owner" do
+
+        before :each do
+          my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 10.minutes.from_now
+        end
+
+        it "doesn't create a new lock" do
+          lock.acquire
+          expect(my_collection.find(key: 'my_lock').count).to be 1
+        end
+
+        it "returns true" do
+          expect(lock.acquire).to be_true
+        end
+
+        it "sets this instance as acquired" do
+          lock.acquire
+          expect(lock.instance_variable_get('@acquired')).to be_true
+        end
+
+      end
+
+      context "when the lock cannot be acquired" do
+
+        context "and acquisition timeout_in occurs" do
+
+          let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.03, frequency: 0.01 }
+
+          it "should return false" do
+            my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.second.from_now
+            expect(lock.acquire).to be_false
+          end
+
+        end
+
+        context "and acquisition limit is exceeded" do
+
+          let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.4, limit: 3, frequency: 0.01 }
+
+          it "should return false" do
+            my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.second.from_now
+            expect(lock.acquire).to be_false
+          end
+
+        end
+
+      end
+
+      context "when the lock cannot be acquired and raise option is set to true" do
+
+        context "and acquisition timeout_in occurs" do
+
+          let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.4, limit: 3, frequency: 0.01, should_raise: true }
+
+          it "should raise Mongo::Lock::NotAcquiredError" do
+            my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
+            expect{lock.acquire}.to raise_error Mongo::Lock::NotAcquiredError
+          end
+
+        end
+
+        context "and acquisition limit is exceeded" do
+
+          let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.3, limit: 3, frequency: 0.01, should_raise: true }
+
+          it "should raise Mongo::Lock::NotAcquiredError" do
+            my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
+            expect{lock.acquire}.to raise_error Mongo::Lock::NotAcquiredError
+          end
+
+        end
+
+      end
+
+      context "when options are provided" do
+
+        let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.2, limit: 11, frequency: 0.01, should_raise: true }
+
+        it "overrides the lock's" do
+          my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
+          expect(lock.acquire timeout_in: 0.05, limit: 3, frequency: 0.02, should_raise: false).to be_false
+        end
+
+      end
+
+      context "when a block is provided" do
+
+        let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.2, limit: 11, frequency: 0.01, should_raise: true }
+
+        it "should acquire the lock" do
+          lock.acquire do |lock|
+            expect(Mongo::Lock.available? 'my_lock', owner: 'spence').to be_false
+          end
+        end
+
+        it "should call the block" do
+          expect{ |block| lock.acquire &block }.to yield_with_args lock
+        end
+
+        it "should release the lock" do
+          lock.acquire do |lock|
+            # Do something
+          end
+          expect(Mongo::Lock.available?('my_lock', owner: 'spence')).to be_true
+        end
+
+      end
+
+    end
+
+    describe '.acquire!' do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence' }
+
+      it "calls .acquire with raise errors option set to true" do
+        expect(Mongo::Lock).to receive(:init_and_send).with('my_lock', { limit: 3 }, :acquire!)
+        Mongo::Lock.acquire! 'my_lock', limit: 3
+      end
+
+    end
+
+    describe '#acquire!' do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence' }
+
+      it "calls #acquire with raise errors option set to true" do
+        expect(lock).to receive(:acquire).with({ limit: 3, should_raise: true })
+        lock.acquire! limit: 3
+      end
+
+    end
+
+  end
+
+end