mongo-lock 1.1.4 → 1.2.0

data/lib/mongo-lock/mongo_queries.rb

@@ -1,97 +0,0 @@
-module Mongo
-  class Lock
-    class MongoQueries
-
-      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

data/spec/acquire_spec.rb

@@ -1,217 +0,0 @@
-require 'spec_helper'
-
-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, 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, 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, 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, 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, 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, raise: true })
-      lock.acquire! limit: 3
-    end
-
-  end
-
-end

data/spec/acquired_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  describe '#acquired?' do
-
-    let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
-
-    context "when the lock has been acquired" do
-
-      it "returns true" do
-        lock.acquire
-        expect(lock.acquired?).to be_true
-      end
-
-    end
-
-    context "when the lock hasn't been acquired" do
-
-      it "returns false" do
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
-        lock.acquire
-        expect(lock.acquired?).to be_false
-      end
-
-    end
-
-    context "when the lock was acquired but has since expired" do
-
-      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.1 }
-
-      it "returns false" do
-        lock.acquire
-        sleep 0.2
-        expect(lock.acquired?).to be_false
-      end
-
-    end
-
-    context "when the lock was acquired but has since been released" do
-
-      it "returns false" do
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
-        lock.acquire
-        lock.release
-        expect(lock.acquired?).to be_false
-      end
-
-    end
-
-  end
-
-end

data/spec/available_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  describe '.available?' do
-
-    it "creates a new Mongo::Lock instance and returns whether it is available" do
-      expect(Mongo::Lock.available? 'my_lock').to be_true
-    end
-
-    it "calls #available?" do
-      expect_any_instance_of(Mongo::Lock).to receive(:available?)
-      Mongo::Lock.available? 'my_lock'
-    end
-
-    context "when options are provided" do
-
-      it "passes them to the new lock" do
-        Mongo::Lock.acquire 'my_lock', { owner: 'spence' }
-        expect(Mongo::Lock.available?('my_lock', { owner: 'spence' })).to be_true
-      end
-
-    end
-
-  end
-
-  describe '#available?' do
-
-    let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
-
-    context "when the lock is available" do
-
-      it "returns true" do
-        expect(lock.available?).to be_true
-      end
-
-    end
-
-    context "when the lock is expired" do
-
-      it "returns true" do
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
-        expect(lock.available?).to be_true
-      end
-
-    end
-
-    context "when the lock is already acquired but by this owner" do
-
-      it "returns true" do
-        my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
-        expect(lock.available?).to be_true
-      end
-
-    end
-
-    context "when the lock is already acquired" do
-
-      it "returns false" do
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
-        expect(lock.available?).to be_false
-      end
-
-    end
-
-  end
-
-end

data/spec/clear_expired_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  describe '.clear_expired' do
-
-    before :each do
-      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
-    end
-
-    let!(:locks) do
-      my_collection.insert key: 'tobies_lock', owner: 'tobie', expires_at: 1.minute.from_now, ttl: 1.minute.from_now
-      my_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
-      other_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
-      another_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
-    end
-
-    it "deletes expired locks in all reegistered collections" do
-      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
-      other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
-      Mongo::Lock.clear_expired
-      expect(my_collection.find().count).to be 1
-      expect(other_collection.find().count).to be 1
-    end
-
-    context "when a collection is provided" do
-
-      before do
-        Mongo::Lock.clear_expired collection: other_collection
-      end
-
-      it "does release locks in that collection" do
-        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-      end
-
-      it "doesn't release locks in other collections" do
-        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-      end
-
-    end
-
-    context "when a collection symbol is provided" do
-
-      before do
-        Mongo::Lock.clear_expired collection: :other
-      end
-
-      it "does release locks in that collection" do
-        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-      end
-
-      it "doesn't release locks in other collections" do
-        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-      end
-
-    end
-
-    context "when collections are provided" do
-
-      before do
-        Mongo::Lock.clear_expired collections: [another_collection, other_collection]
-      end
-
-      it "does release locks in those collection" do
-        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-        expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-      end
-
-      it "doesn't release locks in other collections" do
-        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-      end
-
-      context "when collections is provided as a hash" do
-
-        before do
-          Mongo::Lock.clear_expired collections: { another_collection: another_collection, other_collection: other_collection }
-        end
-
-        it "does release locks in those collection" do
-          expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-          expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-        end
-
-        it "doesn't release locks in other collections" do
-          expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-          expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-        end
-
-      end
-
-    end
-
-  end
-
-end