lock-smith 0.0.9 → 1.0.0

data/lib/locksmith/config.rb

@@ -14,6 +14,11 @@ module Locksmith
       !env(key).nil?
     end
 
+    def pg_lock_space
+      n = "LOCKSMITH_PG_LOCK_SPACE"
+      env(n) && env(n).to_i
+    end
+
     def aws_id
       @aws_id ||= env!("AWS_ID")
     end

data/lib/locksmith/dynamodb.rb

@@ -9,8 +9,6 @@ module Locksmith
     @dynamo_lock = Mutex.new
     @table_lock = Mutex.new
 
-    LOCK_TABLE = "Locks"
-
     def lock(name, opts={})
       opts[:ttl] ||= 60
       opts[:attempts] ||= 3
@@ -50,17 +48,20 @@ module Locksmith
     end
 
     def locks
-      table(LOCK_TABLE)
+      table(lock_table)
     end
 
     def table(name)
-      @table_lock.synchronize {tables[name].items}
+      unless tables[name]
+        @table_lock.synchronize do
+          tables[name] = dynamo.tables[name].load_schema
+        end
+      end
+      tables[name].items
     end
 
     def tables
-      @tables ||= dynamo.tables.
-        map {|t| t.load_schema}.
-        reduce({}) {|h, t| h[t.name] = t; h}
+      @tables ||= {}
     end
 
     def dynamo
@@ -70,5 +71,13 @@ module Locksmith
       end
     end
 
+    def lock_table
+      @lock_table
+    end
+
+    def lock_table=(table_name)
+      @lock_table = table_name
+    end
+
   end
 end

data/lib/locksmith/pg.rb

@@ -1,31 +1,49 @@
 require 'zlib'
 require 'uri'
+require 'timeout'
+require 'locksmith/config'
+
 module Locksmith
   module Pg
-  extend self
-  BACKOFF = 0.5
+    extend self
 
-    def lock(name)
-      i = Zlib.crc32(name)
-      result = nil
-      begin
-        sleep(BACKOFF) until write_lock(i)
-        if block_given?
-          result = yield
+    def lock(name, opts={})
+      opts[:ttl] ||= 60
+      opts[:attempts] ||= 3
+      opts[:lspace] ||= (Config.pg_lock_space || -2147483648)
+
+      if create(name, opts)
+        begin Timeout::timeout(opts[:ttl]) {return(yield)}
+        ensure delete(name, opts)
         end
-        return result
-      ensure
-        release_lock(i)
       end
     end
 
-    def write_lock(i)
-      r = conn.exec("select pg_try_advisory_lock($1)", [i])
-      r[0]["pg_try_advisory_lock"] == "t"
+    def key(name)
+      i = Zlib.crc32(name)
+      # We need to wrap the value for postgres
+      if i > 2147483647
+        -(-(i) & 0xffffffff)
+      else
+        i
+      end
+    end
+
+    def create(name, opts)
+      lock_args = [opts[:lspace], key(name)]
+      opts[:attempts].times.each do |i|
+        res = conn.exec("select pg_try_advisory_lock($1,$2)", lock_args)
+        if res[0]["pg_try_advisory_lock"] == "t"
+          return(true)
+        else
+          return(false) if i == (opts[:attempts] - 1)
+        end
+      end
     end
 
-    def release_lock(i)
-      conn.exec("select pg_advisory_unlock($1)", [i])
+    def delete(name, opts)
+      lock_args = [opts[:lspace], key(name)]
+      conn.exec("select pg_advisory_unlock($1,$2)", lock_args)
     end
 
     def conn=(conn)
@@ -53,4 +71,3 @@ module Locksmith
 
   end
 end
-

data/readme.md

@@ -1,13 +1,9 @@
-# Locksmith
-
-**This software is beta quality. Check back later for production quality.**
+# lock-smith
 
 A library of locking algorithms for a variety of data stores. Supported Data Stores:
 
 * DynamoDB
 * PostgreSQL
-* TODO: Doozerd
-* TODO: Zookeeper
 
 ## Usage
 
@@ -58,20 +54,16 @@ Locksmith::Pg.lock("my-resource") do
 end
 ```
 
-## Why Locksmith
+#### Options
 
-Locking code is tricky. Ideally, I would write it once, verify in production for
-a year then never think about it again.
+* lspace - This defines which lock space lock-smith will use. This is handy if you have multiple applications using advisory locks.
+* ttl - Wraps your block in a timeout. Be sure to handle `Timeout::Error`.
+* attempts - Number of attempts to try advisory lock. Your code will only run once.
 
 ## Hacking on Locksmith
 
 There are still some Data Stores to implement, follow the pattern for PostgreSQLand DynamoDB and submit a pull request.
 
-## Contributors
-
-* Ryan Smith
-* Blake Gentry
-
 ## License
 
 Copyright (C) 2012 Ryan Smith

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lock-smith
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -48,4 +48,3 @@ signing_key:
 specification_version: 3
 summary: Locking is hard. Write it once.
 test_files: []
-has_rdoc: