locker 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/spec/database.yml

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Zencoder
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# Locker
+
+Locker is a locking mechanism for limiting the concurrency of ruby code using the database.
+
+Locker is dependent on Postgres and the ActiveRecord (>= 2.3.14) gem.
+
+## The Basics
+
+In its simplest form it can be used as follows:
+
+```ruby
+Locker.run("unique-key") do
+  # Code that only one process should be running
+end
+```
+
+## What does it do?
+
+Suppose you have a process running on a server that continually performs a task. In our examples we'll use an RSS/Atom feed checker:
+
+### Server 1
+
+#### Code (lib/new_feed_checker.rb)
+
+```ruby
+while true
+  FeedChecker.check_for_new_feeds
+end
+```
+
+`script/rails runner lib/new_feed_checker.rb`
+
+This is great if you have only one server, or if you're okay with running the code on only one of your servers and don't care if the server goes down (and thus the code stops running until the server is back up). If you wanted to make this more fault tolerant you might add another server performing the same task:
+
+### Server 2
+
+*Same as Server 1*
+
+This would work fantastic, so long as `FeedChecker.check_for_new_feeds` is safe to run concurrently on two or more servers. If it's not safe to run concurrently, you need to either make it concurrency-safe or make sure only one server runs the code at any given time. This is where Locker comes in. Lets change the code to take advantage of Locker.
+
+### Server 1 and 2
+
+#### Code (lib/new_feed_checker.rb)
+
+```ruby
+Locker.run("new-feed-checker") do # One server will get the lock
+  # Only one server will get here
+  while true
+    FeedChecker.check_for_new_feeds
+  end
+end # Lock is released at this point
+```
+
+`script/rails runner lib/new_feed_checker.rb`
+
+When we run this code on both servers, only one server will obtain the lock and run `FeedChecker.check_for_new_feeds`. The other server will simply skip the block entirely. Only the server that obtains the lock will run the code, and only one server can obtain the lock at any given time. The first server to get to the lock wins! After the server that obtained the lock finishes running the code block, the lock will be released.
+
+This is great! We've made sure that only one server can run the code at any given time. But wait! Since the server that didn't obtain the lock just skips the code and finishes running we still can't handle one of the servers going down. If only we could wait for the lock to become available instead of skipping the block. Good news, we can!
+
+### Server 1 and 2
+
+#### Code (lib/new_feed_checker.rb)
+
+```ruby
+Locker.run("new-feed-checker", :blocking => true) do
+  # Only one server will get here at a time. The other server will patiently wait.
+  while true
+    FeedChecker.check_for_new_feeds
+  end
+end # Lock is released at this point
+```
+
+`script/rails runner lib/new_feed_checker.rb`
+
+The addition of `:blocking => true` means that whichever server doesn't obtain the lock at first will simply wait and keep trying to get the lock. If the server that first obtains the lock goes down at any point, the second server will automatically take over. By using this technique we've made it so that we don't need to make the code handle concurrency while simultaneously making sure that the code stays running even if a server goes down.
+
+## Installation
+
+If you're using bundler you can add it to your 'Gemfile':
+
+```ruby
+gem "locker"
+```
+
+Then, of course, `bundle install`.
+
+Otherwise you can just `gem install locker`.
+
+## Setup
+
+This gem includes generators for Rails 3.0+:
+
+```bash
+script/rails generate locker [ModelName]
+```
+
+The 'ModelName' defaults to 'Lock'. This will generate the Lock model and its migration.
+
+I apologize if you're using Rails 2.3.x, I couldn't be arsed to figure out how to make generators for it and Rails 3.x+, so you'll need to create the migration and the model yourself:
+
+```ruby
+class CreateLocks < ActiveRecord::Migration
+  def self.up
+    create_table :locks do |t|
+      t.string :locked_by
+      t.string :key
+      t.datetime :locked_at
+      t.datetime :locked_until
+    end
+
+    add_index :locks, :key, :unique => true
+  end
+
+  def self.down
+    drop_table :locks
+  end
+end
+```
+
+```ruby
+class Lock < ActiveRecord::Base
+end
+```
+
+## Advanced Usage
+
+Locker uses some rather simple methods to accomplish its purpose. These simple methods include obtaining, renewing, and releasing the locks.
+
+```ruby
+lock = Locker.new("some-unique-key")
+lock.get     # => true  (Lock obtained)
+# Do something that doesn't take too long here
+lock.renew   # => true  (Lock renewed)
+# Do another thing that doesn't take too long here
+lock.release # => false (Lock released)
+```
+
+The locks consist of records in the `locks` table which have a the following columns: `key`, `locked_by`, `locked_at`, and `locked_until`. The `key` column has uniqueness enforced at the database level to prevent race conditions and duplicate locks. `locked_by` has an identifier unique to the process and object running the code block. This unique identifier makes sure that that we know if we should be able to renew our lock. `locked_at` is a utility column for checking how long a lock has been monopolized. `locked_until` tells us when the lock will expire if it is not renewed.
+
+When Locker is used via the `run` method, an auto-renewer thread is run until the `run` block finishes, at which time the lock is released. By default all locks are obtained for 30 seconds and auto-renewed every 10 seconds. Locks that expire can be taken over by other processes or threads. If your lock expires and another process or thread takes over, Locker will raise `Locker::LockStolen`. The lock duration and time between renewals can be customized.
+
+```ruby
+# :lock_for is the lock duration in seconds. Must be greater than 0 and greater than :renew_every
+# :renew_every is the time to sleep between renewals in seconds. Must be greater than 0 and less than :lock_for
+Locker.run("some-unique-key", :lock_for => 60, :renew_every => 5) do
+  # Your code goes here
+end
+```
+
+If you changed the name of the Lock model, or if you have multiple Lock models, you can customize the model to be used either when you run `Locker.run` or on the Locker class itself.
+
+```ruby
+Locker.model = SomeOtherOtherLockModel
+
+Locker.run("some-unique-key") do
+  # Locked using SomeOtherOtherLockModel
+end
+
+Locker.run("some-unique-key", :model => SomeOtherLockModel) do
+  # Locked using SomeOtherLockModel
+end
+```
+
+## A Common pattern
+
+In our use we've settled on a common pattern, one that lets us distribute the load of our processes between our application and/or utility servers while making sure we have no single point of failure. This means that no single server going down (except the database) will stop the code from executing. Continuing from the code above, we'll use the example of the RSS/Atom feed checker, `FeedChecker.check_for_new_feeds`. To improve on the previous examples, we'll make the code rotate among our servers, so over a long enough time period each server will have spent an equal amount of time running the task.
+
+```ruby
+while true
+  Locker.run("new-feed-checker", :blocking => true) do
+    FeedChecker.check_for_new_feeds
+  end
+  sleep(Kernel.rand + 1) # Delay the next try so that the other servers will have a chance to obtain the lock
+end
+```
+
+Instead of the first server to obtain the lock having a monopoly, each server will obtain a lock only for the duration of the call to `FeedChecker.check_for_new_feeds`. We introduce a random delay so that other servers will have a chance to obtain the lock. If we didn't add that delay then after the first server finished running the FeedChecker it would immediately re-obtain the lock. This is due to how the 'blocking' mechanism works. The blocking mechanism will try to obtain the lock then sleep for half a second, repeating continually until the lock is obtained. The random delay, therefore, will make sure that another server will obtain the lock before the first server will attempt to obtain it again (since 1.Xs > 0.5s), while also randomizing the chances of the first server obtaining locks in the future. In effect this will make sure that over a long enough time period each server will have obtained an equal number of locks. A side benefit of this pattern is that if you don't need the code to run constantly you could introduce a much larger sleep and random value.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/autotest/discover.rb

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

data/lib/generators/locker/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate locker [Lock]
+
+    'Lock' is the model name to use for the model.
+
+    This will create:
+        db/migrations/123456_create_locks.rb
+        app/models/locks.rb

data/lib/generators/locker/locker_generator.rb

@@ -0,0 +1,16 @@
+class LockerGenerator < Rails::Generators::NamedBase
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../templates', __FILE__)
+  argument :name, :type => :string, :default => "Lock"
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_locker_files
+    migration_template "migration.rb", "db/migrate/create_#{plural_name}.rb"
+    template "model.rb", "app/models/#{singular_name}.rb"
+  end
+
+end

data/lib/generators/locker/templates/migration.rb

@@ -0,0 +1,29 @@
+class Create<%= plural_name.camelize %> < ActiveRecord::Migration
+  <%- if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1 -%>
+  def change
+    create_table :<%= plural_name %> do |t|
+      t.string :locked_by
+      t.string :key
+      t.datetime :locked_at
+      t.datetime :locked_until
+    end
+
+    add_index :<%= plural_name %>, :key, :unique => true
+  end
+  <%- else -%>
+  def self.up
+    create_table :<%= plural_name %> do |t|
+      t.string :locked_by
+      t.string :key
+      t.datetime :locked_at
+      t.datetime :locked_until
+    end
+
+    add_index :<%= plural_name %>, :key, :unique => true
+  end
+
+  def self.down
+    drop_table :<%= plural_name %>
+  end
+  <%- end -%>
+end

data/lib/generators/locker/templates/model.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/lib/locker.rb

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

data/lib/locker/locker.rb

@@ -0,0 +1,93 @@
+class Locker
+  class LockStolen < StandardError; end
+
+  if !defined?(SecureRandom)
+    SecureRandom = ActiveSupport::SecureRandom
+  end
+
+  attr_accessor :identifier, :key, :renew_every, :lock_for, :model, :locked, :blocking
+
+  class << self
+    attr_accessor :model
+  end
+
+  def initialize(key, options={})
+    @identifier  = "host:#{Socket.gethostname} pid:#{Process.pid} guid:#{SecureRandom.hex(16)}" rescue "pid:#{Process.pid} guid:#{SecureRandom.hex(16)}"
+    @key         = key
+    @renew_every = (options[:renew_every] || 10.seconds).to_f
+    @lock_for    = (options[:lock_for] || 30.seconds).to_f
+    @model       = (options[:model] || self.class.model || ::Lock)
+    @blocking    = !!options[:blocking]
+    @locked      = false
+
+    raise ArgumentError, "renew_every must be greater than 0" if @renew_every <= 0
+    raise ArgumentError, "lock_for must be greater than 0" if @lock_for <= 0
+    raise ArgumentError, "renew_every must be less than lock_for" if @renew_every >= @lock_for
+
+    ensure_key_exists
+  end
+
+  def self.run(key, options={}, &block)
+    locker = new(key, options)
+    locker.run(&block)
+  end
+
+  def run(blocking=@blocking, &block)
+    while !get && blocking
+      sleep 0.5
+    end
+
+    if @locked
+      begin
+        renewer = Thread.new do
+          while @locked
+            sleep @renew_every
+            renew
+          end
+        end
+
+        block.call
+      ensure
+        renewer.exit rescue nil
+        release if @locked
+      end
+
+      true
+    else
+      false
+    end
+  end
+
+  def get
+    @locked = update_all(["locked_by = ?, locked_at = clock_timestamp() at time zone 'UTC', locked_until = clock_timestamp() at time zone 'UTC' + #{lock_interval}", @identifier],
+                         ["key = ? AND (locked_by IS NULL OR locked_by = ? OR locked_until < clock_timestamp() at time zone 'UTC')", @key, @identifier])
+  end
+
+  def release
+    @locked = update_all(["locked_by = NULL"],["key = ? and locked_by = ?", @key, @identifier])
+  end
+
+  def renew
+    @locked = update_all(["locked_until = clock_timestamp() at time zone 'UTC' + #{lock_interval}"], ["key = ? and locked_by = ?", @key, @identifier])
+    raise LockStolen unless @locked
+    @locked
+  end
+
+private
+
+  def lock_interval
+    "interval '#{@lock_for} seconds'"
+  end
+
+  def ensure_key_exists
+    model.find_by_key(@key) || model.create(:key => @key)
+  rescue ActiveRecord::StatementInvalid => e
+    raise unless e.message =~ /duplicate key value violates unique constraint/
+  end
+
+  # Returns a boolean. True if it updates any rows, false if it didn't.
+  def update_all(*args)
+    model.update_all(*args) > 0
+  end
+
+end

data/lib/locker/version.rb

@@ -0,0 +1,3 @@
+class Locker
+  VERSION = "0.0.1"
+end

data/locker.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "locker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "locker"
+  s.version     = Locker::VERSION
+  s.authors     = ["Nathan Sutton", "Justin Greer"]
+  s.email       = ["nate@zencoder.com", "justin@zencoder.com"]
+  s.summary     = %q{Locker is a locking mechanism for limiting the concurrency of ruby code using the database.}
+  s.description = %q{Locker is a locking mechanism for limiting the concurrency of ruby code using the database. It presently only works with PostgreSQL.}
+
+  s.rubyforge_project = "locker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activerecord",  ">=2.3.14"
+  s.add_development_dependency "pg"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "autotest"
+end

data/spec/locker/locker_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Locker do
+  before do
+    Lock.delete_all
+    FakeLock.fake_locks = {}
+  end
+
+  describe "initialization" do
+    it "should have default values" do
+      locker = Locker.new("foo")
+      locker.key.should == "foo"
+      locker.renew_every.should == 10
+      locker.lock_for.should == 30
+      locker.model.should == Lock
+      locker.identifier.should match(/^#{Regexp.escape("host:#{Socket.gethostname} pid:#{Process.pid}")} guid:[a-f0-9]+$/)
+      locker.blocking.should be_false
+      locker.locked.should be_false
+    end
+
+    it "should have some overridable values" do
+      locker = Locker.new("bar", :renew_every => 20.seconds, :lock_for => 1.minute, :blocking => true, :model => FakeLock)
+      locker.key.should == "bar"
+      locker.renew_every.should == 20
+      locker.lock_for.should == 60
+      locker.model.should == FakeLock
+      locker.identifier.should match(/^#{Regexp.escape("host:#{Socket.gethostname} pid:#{Process.pid}")} guid:[a-f0-9]+$/)
+      locker.blocking.should be_true
+      locker.locked.should be_false
+    end
+
+    it "should ensure that the key exists" do
+      Lock.find_by_key("baz").should be_nil
+      Locker.new("baz", :renew_every => 20.seconds, :lock_for => 1.minute, :blocking => true)
+      Lock.find_by_key("baz").should_not be_nil
+      Locker.new("baz", :renew_every => 20.seconds, :lock_for => 1.minute, :blocking => true)
+    end
+
+    it "should validate renew_every and lock_for values" do
+      expect{ Locker.new("foo", :renew_every => 0) }.to raise_error(ArgumentError)
+      expect{ Locker.new("foo", :renew_every => 1) }.to_not raise_error
+      expect{ Locker.new("foo", :lock_for => 0) }.to raise_error(ArgumentError)
+      expect{ Locker.new("foo", :renew_every => 4, :lock_for => 2) }.to raise_error(ArgumentError)
+      expect{ Locker.new("foo", :renew_every => 1, :lock_for => 1.00001) }.to_not raise_error
+    end
+  end
+
+  describe "locking" do
+    it "should lock a record" do
+      locker = Locker.new("foo")
+      locker.get.should be_true
+      lock = Lock.find_by_key("foo")
+      lock.locked_until.should be <= (Time.now.utc + locker.lock_for)
+      lock.locked_by.should == locker.identifier
+      lock.locked_at.should be < Time.now.utc
+    end
+
+    it "should renew a lock" do
+      locker = Locker.new("foo")
+      locker.get.should be_true
+      lock = Lock.find_by_key("foo")
+      lock.locked_until.should be <= (Time.now.utc + locker.lock_for)
+      lock.locked_by.should == locker.identifier
+      lock.locked_at.should be < Time.now.utc
+      locker.renew.should be_true
+      lock = Lock.find_by_key("foo")
+      lock.locked_until.should be <= (Time.now.utc + locker.lock_for)
+      lock.locked_by.should == locker.identifier
+      lock.locked_at.should be < Time.now.utc
+    end
+
+    it "should raise when someone steals the lock" do
+      locker = Locker.new("foo")
+      locker.get.should be_true
+      lock = Lock.find_by_key("foo")
+      lock.update_attribute(:locked_by, "someone else")
+      expect{ locker.renew }.to raise_error(Locker::LockStolen)
+    end
+  end
+
+  describe "blocking" do
+    before do
+      @first_locker = Locker.new("foo", :renew_every => 0.2.second, :lock_for => 0.6.second)
+      @second_locker = Locker.new("foo")
+      @first_locker.get
+    end
+
+    it "should block and wait for the first lock to release before running the second" do
+      start_time = Time.now.to_f
+      @second_locker.run(true){"something innocuous"}
+      end_time = Time.now.to_f
+      time_ran = (end_time - start_time)
+      time_ran.should be >= 0.6, "Oops, time was #{end_time-start_time} seconds"
+    end
+  end
+
+  describe "non-blocking" do
+    before do
+      @first_locker = Locker.new("foo")
+      @second_locker = Locker.new("foo")
+      @first_locker.get
+    end
+
+    it "should return false when we can't obtain the lock" do
+      @second_locker.run{raise "SHOULD NOT RUN KTHXBAI"}.should be_false
+      @first_locker.run{ "something" }.should be_true
+    end
+
+    it "should take less than half a second to fail" do
+      start_time = Time.now.to_f
+      return_value = @second_locker.run{raise "SHOULD NOT RUN KTHXBAI"}
+      end_time = Time.now.to_f
+      return_value.should be_false
+      run_time = (end_time - start_time)
+      run_time.should be < 0.5
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'bundler/setup'
+require 'active_record'
+
+require 'locker'
+
+ActiveRecord::Base.time_zone_aware_attributes = true
+ActiveRecord::Base.default_timezone = "UTC"
+
+config = YAML.load_file(File.join(File.dirname(__FILE__), 'database.yml'))
+ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+begin
+  ActiveRecord::Base.establish_connection(config)
+rescue
+  ActiveRecord::Base.connection.create_database(config['database'], config.merge("encoding" => config['encoding'] || ENV['CHARSET'] || 'utf8'))
+  ActiveRecord::Base.establish_connection(config)
+end
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS locks")
+ActiveRecord::Base.connection.create_table(:locks) do |t|
+  t.string :locked_by
+  t.string :key
+  t.datetime :locked_at
+  t.datetime :locked_until
+end
+ActiveRecord::Base.connection.add_index :locks, :key, :unique => true
+
+class Lock < ActiveRecord::Base
+end
+
+class FakeLock
+  attr_accessor :locked_by, :key, :locked_at, :locked_until
+
+  cattr_accessor :fake_locks
+  self.fake_locks = {}
+
+  def self.find_by_key(key)
+    fake_locks[key]
+  end
+
+  def self.create(attributes={})
+    fake_locks[attributes[:key]] = new(attributes)
+    true
+  end
+
+  def initialize(attributes={})
+    attributes.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.before do
+    ActiveRecord::Base.connection.increment_open_transactions
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+  c.after do
+    ActiveRecord::Base.connection.rollback_db_transaction
+    ActiveRecord::Base.connection.decrement_open_transactions
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: locker
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Sutton
+- Justin Greer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-31 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
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !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
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  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
+- justin@zencoder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- autotest/discover.rb
+- lib/generators/locker/USAGE
+- lib/generators/locker/locker_generator.rb
+- lib/generators/locker/templates/migration.rb
+- lib/generators/locker/templates/model.rb
+- lib/locker.rb
+- lib/locker/locker.rb
+- lib/locker/version.rb
+- locker.gemspec
+- spec/locker/locker_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+
+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"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: locker
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: Locker is a locking mechanism for limiting the concurrency of ruby code using the database.
+test_files: 
+- spec/locker/locker_spec.rb
+- spec/spec_helper.rb