distlock 0.0.6 → 0.0.7

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
 .bundle
+.rvmrc
 Gemfile.lock
 pkg/*

data/distlock.gemspec

@@ -19,10 +19,9 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
 
   s.add_development_dependency "rake", "~> 0.9"
+  s.add_development_dependency "rspec", "~> 2.0"
 
   s.add_runtime_dependency "zookeeper", "~> 0.4"
 end

data/lib/distlock/lock_error.rb

@@ -0,0 +1,4 @@
+module Distlock
+  class LockError < StandardError
+  end
+end

data/lib/distlock/version.rb

@@ -1,3 +1,3 @@
 module Distlock
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/lib/distlock/zk/common.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Distlock
   module ZK
     module Common
@@ -7,6 +9,14 @@ module Distlock
         end
       end
 
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
       # does a node exist for the given path?
       def exists?(path)
         puts "checking if #{path} exists"
@@ -42,7 +52,19 @@ module Distlock
         puts lock_path
         result = zk.create(:path => lock_path, :sequence => true, :ephemeral => true)
         puts result
-      end            
+        result[:path]
+      end 
+
+      # access @zk directly here, we don't want to lazy instantiate again if closed already
+      def close
+        begin
+          @zk.close if @zk
+        rescue StandardError, ZookeeperExceptions::ZookeeperException => error
+          logger.error("Distlock::ZK::Common#close: caught and squashed error while closing connection - #{error}")
+        end
+
+        @zk = nil
+      end                 
     end
   end
 end

data/lib/distlock/zk/exclusive_lock.rb

@@ -0,0 +1,154 @@
+module Distlock
+  module ZK
+  	class ExclusiveLock
+      include Distlock::ZK::Common
+
+      WATCHER_TIMEOUT = 60 #seconds
+
+      def initialize(options={})
+        defaults = {:host => "localhost:2181", :timeout => 10, :root_path => "/lock/exclusive/default"}
+        @options = defaults.merge(options)
+      end
+
+      def owner?
+        @owner
+      end
+      
+      def my_lock
+        @my_lock
+      end
+
+      def do_watcher(watcher, lock)
+        if watcher.type == ZookeeperConstants::ZOO_DELETED_EVENT
+          logger.debug "Distlock::ZK::ExclusiveLock#do_watcher: watcher called for delete of node - #{lock}"
+        else
+          if watcher.type == ZookeeperConstants::ZOO_CREATED_EVENT
+            logger.error "Distlock::ZK::ExclusiveLock#do_watcher: watcher called for creation of node (should never happen for an ephemeral node?) - #{lock}"
+          elsif watcher.type == ZookeeperConstants::ZOO_SESSION_EVENT
+            logger.error "Distlock::ZK::ExclusiveLock#do_watcher: watcher called for zoo session event, closing the session for this client - #{lock}"
+          else
+            logger.error "Distlock::ZK::ExclusiveLock#do_watcher: watcher called for unexpected event, closing the session for this client - #{lock}, event - #{watcher.type}"
+          end
+
+          close
+          raise LockError.new("Distlock::ZK::ExclusiveLock#do_watcher: got an unexpected watcher type - #{watcher.type}")
+        end
+
+        @watcher_called=true
+      end
+
+      def check_for_existing_lock(path)
+        children = zk.get_children(:path => path)[:children].sort{|a,b|a.split('-').last <=> b.split('-').last}
+        children.detect do |child| 
+          logger.debug "checking existing lock for our client_id - #{child} vs. #{zk.client_id}"
+          if child.split('-')[1] == "#{zk.client_id}"
+            logger.debug "found existing lock for client_id #{zk.client_id}, lock - #{child}, reusing"
+            return "#{path}/#{child}"
+          end
+        end
+      end
+
+      def lock(path)
+        @owner = false
+        
+        safe_create(path)
+        
+        # TODO - combine these into a single method like find_or_create
+        lock = check_for_existing_lock(path)
+        lock = create_sequenced_ephemeral(path) unless lock
+        
+        logger.debug "my lock path - #{lock}"
+        @my_lock = lock
+        result = _get_lock(lock)
+        logger.info("Distlock::ZK::ExclusiveLock#lock: lock acquired - #{lock}")
+        
+        result
+      end
+
+      def unlock(lock = @my_lock)
+        return unless lock
+
+        logger.debug "unlocking - #{lock}"
+        
+        zk.delete(:path => lock)
+        
+        if lock == @my_lock
+          @my_lock = nil
+          @owner = false
+        end
+      end
+
+      def _get_lock(lock)  
+        logger.debug "_get_lock: entered for #{lock}"
+
+        while !@owner
+
+          path = lock.split('/')[0...-1].join('/')
+        
+          # TODO - pass this in as parameter?
+          children = zk.get_children(:path => path)[:children].sort{|a,b|a.split('-').last <=> b.split('-').last}
+          lock_last = lock.split('/').last
+          lock_idx = children.index(lock_last)
+
+          if lock_idx.nil?
+            logger.error("Distlock::ZK::ExclusiveLock#_get_lock: failed to find our lock in the node children (connection reset?)")
+            raise LockError.new("failed to find our lock in the node children (connection reset?)")
+          elsif lock_idx == 0  
+            logger.debug "lock acquired (client id - #{zk.client_id}), lock - #{lock}"
+            @owner = true
+            return true
+          else
+            logger.debug "Distlock::ZK::ExclusiveLock#_get_lock: lock contention for #{lock} - #{children.inspect} (my client id - #{zk.client_id})"
+            logger.info "Distlock::ZK::ExclusiveLock#_get_lock: lock contention - #{lock}"
+
+            to_watch = "#{path}/#{children[lock_idx-1]}"
+            logger.debug "about to set watch on - #{to_watch}"
+
+            # 2-step process so we minimise the chance of setting watches on the node if it does not exist for any reason
+            @watcher_called=false
+            @watcher = Zookeeper::WatcherCallback.new { do_watcher(@watcher, lock) }
+            resp = zk.stat(:path => to_watch)
+            resp = zk.stat(:path => to_watch, :watcher => @watcher) if resp[:stat].exists
+
+            if resp[:stat].exists
+              logger.info "Distlock::ZK::ExclusiveLock#_get_lock: watcher set, node exists, watching - #{to_watch}, our lock - #{lock}"
+              start_time = Time.now
+              while !@watcher_called
+                sleep 0.1
+
+                if (start_time + WATCHER_TIMEOUT) < Time.now
+                  logger.error("Distlock::ZK::ExclusiveLock#_get_lock: timed out while watching - #{to_watch}, our lock - #{lock}, closing session and bombing out")
+                  close
+                  raise LockError.new("Distlock::ZK::ExclusiveLock#_get_lock timed out while waiting for watcher")
+                end
+              end
+            else
+              logger.error("Distlock::ZK::ExclusiveLock#_get_lock: node we are watching does not exist, closing session, lock - #{lock}")
+              close
+              raise LockError.new("node we tried to watch does not exist")
+            end
+          end
+        end
+      end
+
+      def with_lock(path="/distlock/zk/exclusive_lock/default")                            
+        begin
+          lock(path)
+          yield if block_given?
+        rescue ZookeeperExceptions::ZookeeperException::SessionExpired => e
+          close
+          raise LockError.new("error encountered while attempting to obtain lock - #{e}, zookeeper session has been closed")
+        rescue ZookeeperExceptions::ZookeeperException => e
+          raise LockError.new("error encountered while attempting to obtain lock - #{e}")
+        ensure
+          begin
+            unlock
+          rescue ZookeeperExceptions::ZookeeperException => e
+            logger.error("Distlock::ZK::ExclusiveLock#with_lock: error while unlocking - #{e}, closing session to clean up our lock")
+            close
+          end
+        end
+      end            
+    end
+  end
+end

data/lib/distlock/zk/zk.rb

@@ -1,6 +1,6 @@
 require 'zookeeper'
 require 'distlock/zk/common'
-require 'distlock/zk/affinity_pool'
+require 'distlock/zk/exclusive_lock'
 
 module Distlock
   module ZK

data/lib/distlock.rb

@@ -1,10 +1,11 @@
 require 'distlock/version'
+require 'distlock/lock_error'
 require 'distlock/zk/zk'
 
 module Distlock
 end
 
-# convenience so we can use either name
+# convenience so we can use either Distlock or DistLock
 module DistLock
   include Distlock
 end

data/spec/zk_common_spec.rb

@@ -0,0 +1,11 @@
+require 'distlock/zk/common'
+
+class ZKFoo
+  include Distlock::ZK::Common
+end
+
+describe Distlock::ZK::Common do
+  it "should do something" do
+    true
+  end
+end

metadata

@@ -1,45 +1,78 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: distlock
-version: !ruby/object:Gem::Version
-  version: 0.0.6
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 7
+  version: 0.0.7
 platform: ruby
-authors:
+authors: 
 - Simon Horne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-31 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-04-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &70294611917200 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.9'
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
   prerelease: false
-  version_requirements: *70294611917200
-- !ruby/object:Gem::Dependency
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: zookeeper
-  requirement: &70294611916060 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.4'
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
   type: :runtime
-  prerelease: false
-  version_requirements: *70294611916060
+  version_requirements: *id003
 description: Distributed Locking
-email:
+email: 
 - simon@soulware.co.uk
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - Gemfile
 - README
@@ -47,38 +80,45 @@ files:
 - distlock.gemspec
 - lib/dist_lock.rb
 - lib/distlock.rb
+- lib/distlock/lock_error.rb
 - lib/distlock/version.rb
-- lib/distlock/zk/affinity_pool.rb
 - lib/distlock/zk/common.rb
+- lib/distlock/zk/exclusive_lock.rb
 - lib/distlock/zk/zk.rb
+- spec/zk_common_spec.rb
+has_rdoc: true
 homepage: http://soulware.github.com/distlock
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -2701141366311173259
-required_rubygems_version: !ruby/object:Gem::Requirement
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -2701141366311173259
+      version: "0"
 requirements: []
+
 rubyforge_project: distlock
-rubygems_version: 1.8.10
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Distributed Locking
-test_files: []
+test_files: 
+- spec/zk_common_spec.rb

data/lib/distlock/zk/affinity_pool.rb

@@ -1,13 +0,0 @@
-module Distlock
-  module ZK
-  	class AffinityPool
-      include Distlock::ZK::Common
-
-      def initialize(options={})
-        defaults = {:host => "localhost:2181", :timeout => 10, :root_path => "/affinity/pool/test"}
-        @options = defaults.merge(options)
-      end
-
-    end
-  end
-end