locker 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 5de726ed22ab717d6b7d4c46b78f05ce2d1ffe80
+  metadata.gz: 1c082e3e46be1848f8ebaad6a48f9fd640fda707
+SHA512: 
+  data.tar.gz: 1500e4acd3c15fb9d864bbdbdb30b1fd6d92808d63fe1acd904046ed17f089553706939a54adb7723334eca23e1c298eb7ac66708308de56c0ef82fc5dc372de
+  metadata.gz: 91f9f3529ffe477582aed59b861a446134b055e4e293d40daf39596f6ae6c1e2fa5d03209a7145c00126f721f9deb11704bdf7a5ffbc4f4fbe341dacfc62d18f

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.2.0
+
+[Full Changelog](http://github.com/zencoder/locker/compare/v0.1.0...v0.2.0)
+
+Enhancements:
+
+* Added the ability to use Postgres advisory locks via Locker::Advisory.
+
+## 0.1.0
+
+[Full Changelog](http://github.com/zencoder/locker/compare/v0.0.3...v0.1.0)
+
+**NOTE:** You will need to manually add the `sequence` column. See the README for more information.
+
+Enhancements:
+
+* Added a `sequence` column that gets incremented when a lock is acquired. The value of sequence is then passed into the lock block.
+* Added multi-ruby testing using Travis CI. Tests passes in just about everything.
+* Now supports MRI 1.8.7+, rbx, and jruby.
+
+Bugfixes:
+
+* Removed weirdness around defaulting to using ActiveSupport::SecureRandom when SecureRandom was missing, which should have never been the case.

data/README.md

@@ -14,6 +14,15 @@ In Rails 3.x+:
 
     script/rails generate migration add_sequence_to_locks sequence:bigint
 
+Then add a line that changes the default of the column to zero and updates the existing records:
+
+    change_column_default :locks, :sequence, 0
+    execute "UPDATE locks SET sequence = 0"
+
+## Supported Rubies
+
+See [the travis configuration file](https://github.com/zencoder/locker/blob/master/.travis.yml) for which ruby versions we support.
+
 ## The Basics
 
 In its simplest form it can be used as follows:

data/lib/locker.rb

@@ -1,3 +1,4 @@
 require "active_record"
 require "locker/locker"
+require "locker/advisory"
 require "locker/version"

data/lib/locker/advisory.rb

@@ -0,0 +1,117 @@
+require "zlib"
+
+class Locker
+  class Advisory
+    class LockConnectionLost < StandardError; end
+
+    attr_reader :key, :crc, :lockspace, :blocking, :locked
+
+    MAX_LOCK = 2147483647
+    MIN_LOCK = -2147483648
+    OVERFLOW_ADJUSTMENT = 2**32
+
+    def initialize(key, options={})
+      raise ArgumentError, "key must be a string" unless key.is_a?(String)
+
+      @key       = key
+      @crc       = convert_to_crc(key)
+      @lockspace = (options[:lockspace] || 1)
+      @blocking  = !!options[:blocking]
+      @locked    = false
+
+      if !@lockspace.is_a?(Integer) || @lockspace < MIN_LOCK || @lockspace > MAX_LOCK
+        raise ArgumentError, "The :lockspace option must be an integer between #{MIN_LOCK} and #{MAX_LOCK}"
+      end
+    end
+
+    def self.run(key, options={}, &block)
+      advisory = new(key, options)
+      advisory.run(&block)
+    end
+
+    def run(&block)
+      connection = ActiveRecord::Base.connection_pool.checkout
+      connection.transaction :requires_new => true do
+        ensure_unlocked(connection)
+
+        while !get(connection) && @blocking
+          sleep 0.5
+        end
+
+        if @locked
+          begin
+            parent_thread = Thread.current
+
+            mutex = Mutex.new
+
+            checker = Thread.new do
+              while @locked
+                10.times{ sleep 0.5 if @locked }
+                mutex.synchronize do
+                  if @locked
+                    check(connection, parent_thread)
+                  end
+                end
+              end
+            end
+
+            block.call
+          ensure
+            release(connection) if @locked
+            # Using a mutex to synchronize so that we're sure we're not
+            # executing a query when we kill the thread.
+            mutex.synchronize{}
+            if checker.alive?
+              checker.exit rescue nil
+            end
+          end
+          true
+        else
+          false
+        end
+      end
+    ensure
+      ActiveRecord::Base.connection_pool.checkin(connection) if connection
+    end
+
+  protected
+
+    def get(connection)
+      result = exec_query(connection, "SELECT pg_try_advisory_xact_lock(#{connection.quote(@lockspace)}, #{connection.quote(@crc)})")
+      @locked = successful_result?(result)
+    end
+
+    def release(connection)
+      result = exec_query(connection, "SELECT pg_advisory_unlock(#{connection.quote(@lockspace)}, #{connection.quote(@crc)})")
+      successful_result?(result)
+    end
+
+    def ensure_unlocked(connection)
+      while release(connection); end
+    end
+
+    def check(connection, thread)
+      if !connection.active?
+        @locked = false
+        thread.raise LockConnectionLost
+      end
+    end
+
+    def convert_to_crc(key)
+      crc = Zlib.crc32(key)
+      crc -= OVERFLOW_ADJUSTMENT if crc > MAX_LOCK
+      crc
+    end
+
+    def successful_result?(result)
+      result.rows.size == 1 && result.rows[0].size == 1 && result.rows[0][0] == "t"
+    end
+
+    def exec_query(connection, query)
+      silence_stderr do
+        connection.exec_query(query, "Locker::Advisory")
+      end
+    end
+
+  end
+end

data/lib/locker/version.rb

@@ -1,3 +1,3 @@
 class Locker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/locker/advisory_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Locker::Advisory do
+
+  describe "initialization" do
+    it "should have default values" do
+      advisory = Locker::Advisory.new("foo")
+      advisory.key.should == "foo"
+      advisory.crc.should == -1938594527
+      advisory.lockspace.should == 1
+      advisory.blocking.should be_false
+      advisory.locked.should be_false
+    end
+
+    it "should have some overridable values" do
+      advisory = Locker::Advisory.new("foo", :lockspace => 2, :blocking => true)
+      advisory.lockspace.should == 2
+      advisory.blocking.should be_true
+    end
+
+    it "should validate key" do
+      expect{ Locker::Advisory.new(1) }.to raise_error(ArgumentError)
+    end
+
+    it "should validate lockspace" do
+      expect{ Locker::Advisory.new("foo", :lockspace => Locker::Advisory::MIN_LOCK - 1) }.to raise_error(ArgumentError)
+      expect{ Locker::Advisory.new("foo", :lockspace => Locker::Advisory::MAX_LOCK + 1) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "locking" do
+    it "should lock to the exclusion of other locks and return true on success and false on failure" do
+      lock1 = false
+      lock2 = false
+
+      t = Thread.new do
+        Locker::Advisory.run("foo") do
+          lock1 = true
+          sleep 1
+        end
+      end
+
+      Thread.pass
+
+      lock2_result = Locker::Advisory.run("foo") do
+        lock2 = true
+      end
+
+      lock1_result = t.join
+      lock1.should be_true
+      lock2.should be_false
+      lock1_result.should be_true
+      lock2_result.should be_false
+    end
+
+    it "should release locks after the block is finished" do
+      lock1 = false
+      lock2 = false
+
+      lock1_result = Locker::Advisory.run("foo") do
+        lock1 = true
+      end
+
+      lock2_result = Locker::Advisory.run("foo") do
+        lock2 = true
+      end
+
+      lock1.should be_true
+      lock2.should be_true
+      lock1_result.should be_true
+      lock2_result.should be_true
+    end
+  end
+
+end

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: locker
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Nathan Sutton
@@ -16,21 +10,15 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-04-04 00:00:00 Z
+date: 2014-05-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 2
-        - 3
-        - 14
         version: 2.3.14
   type: :runtime
   version_requirements: *id001
@@ -38,30 +26,21 @@ dependencies:
   name: pg
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
-    - - ">="
+    - &id003 
+      - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    - *id003
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 description: Locker is a locking mechanism for limiting the concurrency of ruby code using the database. It presently only works with PostgreSQL.
 email: 
 - nate@zencoder.com
@@ -75,11 +54,11 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- autotest/discover.rb
 - gemfiles/rails2.gemfile
 - gemfiles/rails3.gemfile
 - generators/locker/USAGE
@@ -91,45 +70,38 @@ files:
 - lib/generators/locker/templates/migration.rb
 - lib/generators/locker/templates/model.rb
 - lib/locker.rb
+- lib/locker/advisory.rb
 - lib/locker/locker.rb
 - lib/locker/version.rb
 - locker.gemspec
+- spec/locker/advisory_spec.rb
 - spec/locker/locker_spec.rb
 - spec/spec_helper.rb
 homepage: 
 licenses: []
 
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id003
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id003
 requirements: []
 
 rubyforge_project: locker
-rubygems_version: 1.8.25
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Locker is a locking mechanism for limiting the concurrency of ruby code using the database.
 test_files: 
+- spec/locker/advisory_spec.rb
 - spec/locker/locker_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }