mongo-lock 1.0.0

data/lib/mongo-lock/configuration.rb

@@ -0,0 +1,72 @@
+module Mongo
+  class Lock
+    class Configuration
+
+      attr_accessor :connections
+      attr_accessor :limit
+      attr_accessor :timeout_in
+      attr_accessor :frequency
+      attr_accessor :expires_after
+      attr_accessor :owner
+      attr_accessor :raise
+
+      def initialize defaults, options, &block
+        options = defaults.merge(options)
+        options[:collections] ||= {}
+        if options[:collection]
+          options[:collections][:default] = options[:collection]
+        end
+        options.each_pair do |key,value|
+          self.send(:"#{key}=",value)
+        end
+        yield self if block_given?
+      end
+
+      def collection= collection
+        collections[:default] = collection
+      end
+
+      def collection collection = :default
+        collection = collection.to_sym if collection.is_a? String
+        if collection.is_a? Symbol
+          collections[collection]
+        else
+          collection
+        end
+      end
+
+      def collections= collections
+        @collections = collections
+      end
+
+      def set_collections_keep_default collections
+        collections[:default] = @collections[:default]
+        @collections = collections
+      end
+
+      def collections
+        @collections ||= {}
+      end
+
+      def to_hash
+        {
+          timeout_in: timeout_in,
+          limit: limit,
+          frequency: frequency,
+          expires_after: expires_after,
+          owner: owner,
+          raise: raise
+        }
+      end
+
+      def owner
+        if @owner.is_a? Proc
+          @owner.call.to_s
+        else
+          @owner.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo-lock/version.rb

@@ -0,0 +1,5 @@
+module Mongo
+  class Lock
+    VERSION = "1.0.0"
+  end
+end

data/mongo-lock.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongo-lock/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = "mongo-lock"
+  spec.version     = Mongo::Lock::VERSION
+  spec.authors     = ["Matthew Spence"]
+  spec.email       = "msaspence@gmail.com"
+  spec.homepage    = "https://github.com/trakio/mongo-lock"
+  spec.summary     = "Pessimistic locking for Ruby and MongoDB"
+  spec.description = "Key based pessimistic locking for Ruby and MongoDB. Is this key avaliable? Yes - Lock it for me for a sec will you. No - OK I'll just wait here until its ready."
+  spec.required_rubygems_version = ">= 1.3.6"
+  spec.license = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # s.add_dependency 'some-gem'
+  spec.extra_rdoc_files = ['README.md', 'LICENSE']
+
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'fuubar'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'activesupport'
+
+end

data/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: locks
+      hosts:
+        - localhost:27017

data/spec/acquire_spec.rb

@@ -0,0 +1,184 @@
+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
+
+  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(collection.find(key: 'my_lock').count).to be 1
+      end
+
+      it "sets the lock to expire" do
+        lock.acquire
+        expect(collection.find(key: 'my_lock').first['expires_at']).to be_within(1.second).of(10.seconds.from_now)
+        expect(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
+        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.04.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
+        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(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
+        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(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
+          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.2.seconds.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
+          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.2.seconds.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, frequency: 0.01, raise: true }
+
+        it "should raise Mongo::Lock::NotAcquiredError" do
+          collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.2.seconds.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
+          collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.2.seconds.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
+        collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.1.seconds.from_now
+        expect(lock.acquire timeout_in: 0.05, limit: 3, frequency: 0.02, raise: false).to be_false
+      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

@@ -0,0 +1,52 @@
+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
+        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
+
+      it "returns false" do
+        collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.01.seconds.from_now
+        lock.acquire
+        sleep 0.02
+        expect(lock.acquired?).to be_false
+      end
+
+    end
+
+    context "when the lock was acquired but has since been released" do
+
+      it "returns false" do
+        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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '.available?' do
+
+    it "creates and returns a new Mongo::Lock instance" do
+      expect(Mongo::Lock.available? 'my_lock').to be_a Mongo::Lock
+    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
+        lock = Mongo::Lock.available?('my_lock', { owner: 'spence' })
+        expect(lock.configuration.owner).to eql 'spence'
+      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
+        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
+        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
+        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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '.clear_expired' do
+
+    it "deletes expired locks in all collections" do
+      Mongo::Lock.configure collections: { default: collection, other: other_collection }
+      collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
+      collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.ago
+      other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
+      other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.ago
+      Mongo::Lock.clear_expired
+      expect(collection.find().count).to be 1
+      expect(other_collection.find().count).to be 1
+    end
+
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe Mongo::Lock::Configuration do
+
+  subject { Mongo::Lock::Configuration.new({}, {}) }
+
+  let (:collections_with_default) { { a: 'a', b: 'b', default: collection } }
+  let (:collections) { { a: 'a', b: 'b' } }
+  let (:collection) { 'default' }
+
+  describe '#initialize' do
+
+    context "when provided with a hash" do
+
+      it "sets each value" do
+        config = Mongo::Lock::Configuration.new({}, { limit: 3, timeout_in: 4 })
+        expect(config.limit).to be 3
+        expect(config.timeout_in).to be 4
+      end
+
+      context "when provided with a default connection" do
+
+        it "stores it in the connections hash as :default" do
+          config = Mongo::Lock::Configuration.new({}, { collection: collection, collections: collections })
+          expect(config.collections).to eql collections_with_default
+        end
+
+      end
+
+    end
+
+    context "when provided with a default" do
+
+      it "sets each value" do
+        config = Mongo::Lock::Configuration.new({ limit: 3, timeout_in: 4 }, { limit: 5 })
+        expect(config.limit).to be 5
+        expect(config.timeout_in).to be 4
+      end
+
+      context "when provided with a default connection" do
+
+        it "stores it in the connections hash as :default" do
+          config = Mongo::Lock::Configuration.new({ collections: collections }, { collection: collection})
+          expect(config.collections).to eql collections_with_default
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#collections=" do
+
+    it "should set collections hash" do
+      subject.collections = collections
+      expect(subject.instance_variable_get('@collections')).to be collections
+    end
+
+    it "should remove default from collections hash" do
+      subject.instance_variable_set('@collections', collections_with_default)
+      subject.collections = collections
+      expect(subject.instance_variable_get('@collections')).to be collections
+    end
+
+  end
+
+  describe "#set_collections_keep_default" do
+
+    it "should keep default in the collections hash" do
+      subject.instance_variable_set('@collections', collections_with_default)
+      subject.set_collections_keep_default collections
+      expect(subject.instance_variable_get('@collections')).to eql collections_with_default
+    end
+
+  end
+
+  describe "#collections" do
+
+    it "should return the collections hash" do
+      subject.instance_variable_set('@collections', collections)
+      expect(subject.collections).to be collections
+    end
+
+  end
+
+  describe "#collection=" do
+
+    it "should set the default collection" do
+      subject.collection = collection
+      expect(subject.instance_variable_get('@collections')[:default]).to be collection
+    end
+
+  end
+
+  describe "#collection" do
+
+    context "when a symbol is provided" do
+
+      it "should return that collection" do
+        subject.instance_variable_set('@collections', collections)
+        expect(subject.collection :a).to eql 'a'
+      end
+
+    end
+
+    context "when a string is provided" do
+
+      it "should return that collection" do
+        subject.instance_variable_set('@collections', collections)
+        expect(subject.collection 'a').to eql 'a'
+      end
+
+    end
+
+    context "when it's any other object is" do
+
+      it "should return that collection" do
+        my_collection = Object.new
+        subject.instance_variable_set('@collections', collections)
+        expect(subject.collection my_collection).to be my_collection
+      end
+
+    end
+
+    context "when a symbol isn't provided" do
+
+      it "should return the default collection" do
+        subject.instance_variable_set('@collections', collections_with_default)
+        expect(subject.collection).to eql 'default'
+      end
+
+    end
+
+  end
+
+  describe "#timeout_in=" do
+
+    it "should set the timeout_in value" do
+      subject.timeout_in = 123
+      expect(subject.instance_variable_get('@timeout_in')).to be 123
+    end
+
+  end
+
+  describe "#timeout_in" do
+
+    it "should return the timeout_in value" do
+      subject.instance_variable_set('@timeout_in', 456)
+      expect(subject.timeout_in).to be 456
+    end
+
+  end
+
+  describe "#limit=" do
+
+    it "should set the limit value" do
+      subject.limit = 7
+      expect(subject.instance_variable_get('@limit')).to be 7
+    end
+
+  end
+
+  describe "#limit" do
+
+    it "should return the limit value" do
+      subject.instance_variable_set('@limit', 8)
+      expect(subject.limit).to be 8
+    end
+
+  end
+
+  describe "#frequency=" do
+
+    it "should set the frequency value" do
+      subject.frequency = 9
+      expect(subject.instance_variable_get('@frequency')).to be 9
+    end
+
+  end
+
+  describe "#frequency" do
+
+    it "should return the frequency value" do
+      subject.instance_variable_set('@frequency', 1)
+      expect(subject.frequency).to be 1
+    end
+
+  end
+
+  describe "#expires_after=" do
+
+    it "should set the expires_after value" do
+      subject.expires_after = 9
+      expect(subject.instance_variable_get('@expires_after')).to be 9
+    end
+
+  end
+
+  describe "#expires_after" do
+
+    it "should return the expires_after value" do
+      subject.instance_variable_set('@expires_after', 1)
+      expect(subject.expires_after).to be 1
+    end
+
+  end
+
+  describe "#owner" do
+
+    it "should return the owner value" do
+      subject.instance_variable_set('@owner', 'spence')
+      expect(subject.owner).to eql 'spence'
+    end
+
+    context "when owner is a Proc" do
+
+      it "is called" do
+        proc = Proc.new { }
+        expect(proc).to receive(:call)
+        subject.instance_variable_set('@owner', proc)
+        subject.owner
+      end
+
+    end
+
+  end
+
+  describe "#owner=" do
+
+    it "should set the owner value" do
+      subject.owner = 'spence'
+      expect(subject.instance_variable_get('@owner')).to eql 'spence'
+    end
+
+  end
+
+end