zk 1.8.0 → 1.9.0

data/.dotfiles/ruby-gemset

@@ -0,0 +1 @@
+zk

data/.dotfiles/ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p429

data/.gitignore

@@ -11,3 +11,5 @@ wiki
 zookeeper
 coverage/
 .ctags_paths
+.ruby-gemset
+.ruby-version

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "releaseops"]
 	path = releaseops
-	url = git://github.com/slyphon/releaseops.git
+	url = git://github.com/zk-ruby/releaseops.git

data/.travis.yml

@@ -2,6 +2,7 @@
 notifications:
   email:
     - slyphon@gmail.com
+    - eric@5stops.com
 
 env:
   - SPAWN_ZOOKEEPER='true'

data/README.markdown

@@ -1,6 +1,6 @@
 # ZK #
 
-[![Build Status (master)](https://secure.travis-ci.org/slyphon/zk.png?branch=master)](http://travis-ci.org/slyphon/zk)
+[![Build Status (master)](https://secure.travis-ci.org/zk-ruby/zk.png?branch=master)](http://travis-ci.org/zk-ruby/zk)
 
 ZK is an application programmer's interface to the Apache [ZooKeeper][] server. It is based on the [zookeeper gem][] which is a multi-Ruby low-level driver. Currently MRI 1.8.7, 1.9.2, 1.9.3, REE, and JRuby are supported. Rubinius 2.0.testing is supported-ish (it's expected to work, but upstream is unstable, so YMMV). 
 
@@ -16,10 +16,10 @@ Development is sponsored by [Snapfish][] and has been generously released to the
 
 [ZK::Client::Base]: http://rubydoc.info/gems/zk/ZK/Client/Base
 [ZooKeeper]: http://zookeeper.apache.org/ "Apache ZooKeeper"
-[zookeeper gem]: https://github.com/slyphon/zookeeper "slyphon-zookeeper gem"
+[zookeeper gem]: https://github.com/zk-ruby/zookeeper "zookeeper gem"
 [MIT]: http://www.gnu.org/licenses/license-list.html#Expat "MIT (Expat) License"
 [Snapfish]: http://www.snapfish.com/ "Snapfish"
-[RELEASES]: https://github.com/slyphon/zk/blob/master/RELEASES.markdown
+[RELEASES]: https://github.com/zk-ruby/zk/blob/master/RELEASES.markdown
 
 ## What is ZooKeeper? ##
 
@@ -38,7 +38,7 @@ ZooKeeper is easy to deploy in a [Highly Available][ha-config] configuration, an
 [leader election]: http://zookeeper.apache.org/doc/current/recipes.html#sc_leaderElection
 [group membership]: http://zookeeper.apache.org/doc/current/recipes.html#sc_outOfTheBox
 [ha-config]: http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_CrossMachineRequirements "HA config"
-[groups]: https://github.com/slyphon/zk-group
+[groups]: https://github.com/zk-ruby/zk-group
 [locks]: http://rubydoc.info/gems/zk/ZK/Locker
 
 
@@ -62,7 +62,7 @@ In addition to all of that, I would like to think that the public API the ZK::Cl
 [recipes]: http://zookeeper.apache.org/doc/current/recipes.html
 [Mongoid]: http://mongoid.org/
 [EventMachine]: https://github.com/eventmachine/eventmachine
-[zk-eventmachine]: https://github.com/slyphon/zk-eventmachine
+[zk-eventmachine]: https://github.com/zk-ruby/zk-eventmachine
 
 ## Release info / Changelog 
 
@@ -85,7 +85,7 @@ ZK strives to be a complete, correct, and convenient way of interacting with Zoo
 * ZK::Client supports asynchronous calls of all basic methods (get, set, delete, etc.) however these versions are kind of inconvenient to use. For a fully evented stack, try [zk-eventmachine][], which is designed to be compatible and convenient to use in event-driven code.
 
 [twitter/zookeeper]: https://github.com/twitter/zookeeper
-[async-branch]: https://github.com/slyphon/zk/tree/dev%2Fasync-conveniences
+[async-branch]: https://github.com/zk-ruby/zk/tree/dev%2Fasync-conveniences
 [chroot]: http://zookeeper.apache.org/doc/current/zookeeperProgrammers.html#ch_zkSessions
 [YARD]: http://yardoc.org/
 [sessions]: http://zookeeper.apache.org/doc/current/zookeeperProgrammers.html#ch_zkSessions 
@@ -100,19 +100,18 @@ ZK strives to be a complete, correct, and convenient way of interacting with Zoo
 
 ## Dependencies
 
-* The [slyphon-zookeeper gem][szk-gem] ([repo][szk-repo]).
+* The [zookeeper gem][szk-gem] ([repo][szk-repo]).
 
 * For JRuby, the [slyphon-zookeeper\_jar gem][szk-jar-gem] ([repo][szk-jar-repo]), which just wraps the upstream zookeeper driver jar in a gem for easy installation
 
-[szk-gem]: https://rubygems.org/gems/slyphon-zookeeper
-[szk-repo]: https://github.com/slyphon/zookeeper
-[szk-repo-bundler]: https://github.com/slyphon/zookeeper/tree/dev/gemfile/
+[szk-gem]: https://rubygems.org/gems/zookeeper
+[szk-repo]: https://github.com/zk-ruby/zookeeper
+[szk-repo-bundler]: https://github.com/zk-ruby/zookeeper/tree/dev/gemfile/
 [szk-jar-gem]: https://rubygems.org/gems/slyphon-zookeeper_jar
-[szk-jar-repo]: https://github.com/slyphon/zookeeper_jar
+[szk-jar-repo]: https://github.com/zk-ruby/zookeeper_jar
 
 ## Contacting the author
 
-* I'm usually hanging out in IRC on freenode.net in the BRAND NEW #zk-gem channel.
 * if you really want to, you can also reach me via twitter [@slyphon][]
 
 [@slyphon]: https://twitter.com/#!/slyphon

data/RELEASES.markdown

@@ -1,4 +1,9 @@
-This file notes feature differences and bugfixes contained between releases. 
+This file notes feature differences and bugfixes contained between releases.
+
+### v1.9.0 ###
+
+* Semaphores!
+* shared/exclusive lock fixes
 
 ### v1.8.0 ###
 

data/lib/zk/client/base.rb

@@ -169,7 +169,7 @@ module ZK
       # Create a node with the given path. The node data will be the given data.
       # The path is returned.
       # 
-      # If the ephemeral option is given, the znode creaed will be removed by the
+      # If the ephemeral option is given, the znode created will be removed by the
       # server automatically when the session associated with the creation of the
       # node expires. Note that ephemeral nodes cannot have children.
       # 

data/lib/zk/locker.rb

@@ -92,6 +92,7 @@ module ZK
   module Locker
     SHARED_LOCK_PREFIX  = 'sh'.freeze
     EXCLUSIVE_LOCK_PREFIX = 'ex'.freeze
+    SEMAPHORE_LOCK_PREFIX = 'sem'.freeze
 
     @default_root_lock_node = '/_zklocking'.freeze unless @default_root_lock_node
 
@@ -118,6 +119,16 @@ module ZK
         ExclusiveLocker.new(client, name, *args)
       end
 
+      # Create a {Semaphore} instance
+      #
+      # @param client (see Semaphore#initialize)
+      # @param name (see Semaphore#initialize)
+      # @param semaphore_size (see Semaphore#initialize)
+      # @return [Semaphore]
+      def semaphore(client, name, semaphore_size, *args)
+        Semaphore.new(client, name, semaphore_size, *args)
+      end
+
       # Clean up dead locker directories. There are situations (particularly
       # session expiration) where a lock's directory will never be cleaned up.
       #
@@ -164,4 +175,5 @@ require 'zk/locker/lock_options'
 require 'zk/locker/locker_base'
 require 'zk/locker/shared_locker'
 require 'zk/locker/exclusive_locker'
+require 'zk/locker/semaphore'
 

data/lib/zk/locker/exclusive_locker.rb

@@ -44,59 +44,17 @@ module ZK
       end
 
       private
-        def lock_with_opts_hash(opts)
-          create_lock_path!(EXCLUSIVE_LOCK_PREFIX)
 
-          lock_opts = LockOptions.new(opts)
-
-          if got_write_lock?
-            @mutex.synchronize { @locked = true }
-          elsif lock_opts.blocking?
-            block_until_write_lock!(:timeout => lock_opts.timeout)
-          else
-            false
-          end
-        ensure
-          cleanup_lock_path! unless @mutex.synchronize { @locked }
-        end
-
-        # the node that is next-lowest in sequence number to ours, the one we
-        # watch for updates to
-        def next_lowest_node
-          ary = ordered_lock_children()
-          my_idx = ary.index(lock_basename)
-
-          raise WeAreTheLowestLockNumberException if my_idx == 0
-
-          ary[(my_idx - 1)] 
+        # @private
+        def lock_prefix
+          EXCLUSIVE_LOCK_PREFIX
         end
 
-        def got_write_lock?
-          ordered_lock_children.first == lock_basename
+        # @private
+        def blocking_locks
+          lower_lock_names
         end
-        alias got_lock? got_write_lock?
 
-        def block_until_write_lock!(opts={})
-          begin
-            path = "#{root_lock_path}/#{next_lowest_node}"
-            logger.debug { "#{self.class}##{__method__} path=#{path.inspect}" }
-
-            @mutex.synchronize do
-              logger.debug { "assigning the @node_deletion_watcher" }
-              @node_deletion_watcher = NodeDeletionWatcher.new(zk, path)
-              logger.debug { "broadcasting" }
-              @cond.broadcast
-            end
-
-            logger.debug { "calling block_until_deleted" }
-            Thread.pass
-
-            @node_deletion_watcher.block_until_deleted(opts)
-          rescue WeAreTheLowestLockNumberException
-          end
-
-          @mutex.synchronize { @locked = true }
-        end
     end # ExclusiveLocker
   end # Locker
 end # ZK

data/lib/zk/locker/locker_base.rb

@@ -102,6 +102,11 @@ module ZK
         synchronize { lock_path and File.basename(lock_path) }
       end
 
+      # @private
+      def lock_number
+        synchronize { lock_path and digit_from(lock_path) }
+      end
+
       # returns our current idea of whether or not we hold the lock, which does
       # not actually check the state on the server.
       #
@@ -288,10 +293,6 @@ module ZK
       end
 
       private
-        def lock_with_opts_hash(opts={})
-          raise NotImplementedError
-        end
-
         def synchronize
           @mutex.synchronize { yield }
         end
@@ -318,13 +319,6 @@ module ZK
           retry
         end
 
-        # performs the checks that (according to the recipe) mean that we hold
-        # the lock. used by (#assert!)
-        #
-        def got_lock?
-          raise NotImplementedError
-        end
-
         # prefix is the string that will appear in front of the sequence num,
         # defaults to 'lock'
         #
@@ -395,6 +389,81 @@ module ZK
 
           rval
         end
+
+        # @private
+        def lower_lock_names(watch=false)
+          olc = ordered_lock_children(watch)
+          return olc unless lock_path
+
+          olc.select do |lock|
+            digit_from(lock) < lock_number
+          end
+        end
+
+        # for write locks & semaphores, this will be all locks lower than us
+        # for read locks, this will be all write-locks lower than us.
+        # @return [Array] an array of string node paths
+        def blocking_locks
+          raise NotImplementedError
+        end
+
+        def lock_prefix
+          raise NotImplementedError
+        end
+
+        # performs the checks that (according to the recipe) mean that we hold
+        # the lock. used by (#assert!)
+        #
+        def got_lock?
+          lock_path and blocking_locks.empty?
+        end
+
+        # for write locks & read locks, this will be zero since #blocking_locks
+        # accounts for all locks that could block at all.
+        # for semaphores, this is one less than the semaphore size.
+        # @private
+        # @returns [Integer]
+        def allowed_blocking_locks_remaining
+          0
+        end
+
+        def blocking_locks_full_paths
+          blocking_locks.map { |partial| "#{root_lock_path}/#{partial}"}
+        end
+
+        def lock_with_opts_hash(opts)
+          create_lock_path!(lock_prefix)
+
+          lock_opts = LockOptions.new(opts)
+
+          if got_lock? or (lock_opts.blocking? and block_until_lock!(:timeout => lock_opts.timeout))
+            @mutex.synchronize { @locked = true }
+          else
+            false
+          end
+        ensure
+          cleanup_lock_path! unless @mutex.synchronize { @locked }
+        end
+
+        def block_until_lock!(opts={})
+          paths = blocking_locks_full_paths
+
+          logger.debug { "#{self.class}\##{__method__} paths=#{paths.inspect}" }
+
+          @mutex.synchronize do
+            logger.debug { "assigning the @node_deletion_watcher" }
+            ndw_options = {:threshold => allowed_blocking_locks_remaining}
+            @node_deletion_watcher = NodeDeletionWatcher.new(zk, paths, ndw_options)
+            logger.debug { "broadcasting" }
+            @cond.broadcast
+          end
+
+          logger.debug { "calling block_until_deleted" }
+          Thread.pass
+
+          @node_deletion_watcher.block_until_deleted(opts)
+          true
+        end
     end # LockerBase
   end # Locker
 end # ZK

data/lib/zk/locker/semaphore.rb

@@ -0,0 +1,80 @@
+module ZK
+  module Locker
+    # A semaphore implementation
+    class Semaphore < LockerBase
+      include Exceptions
+
+      @default_root_node = '/_zksemaphore'.freeze unless @default_root_node
+
+      class << self
+        # the default root path we will use when a value is not given to a
+        # constructor
+        attr_accessor :default_root_node
+      end
+
+      def initialize(client, name, semaphore_size, root_node=nil)
+        raise BadArgument, <<-EOMESSAGE unless semaphore_size.kind_of? Integer
+          semaphore_size must be Integer, not #{semaphore_size.inspect}
+        EOMESSAGE
+
+        @semaphore_size = semaphore_size
+
+        super(client, name, root_node || ::ZK::Locker::Semaphore.default_root_node)
+      end
+
+      # (see LockerBase#lock)
+      # obtain a shared lock.
+      #
+      def lock(opts={})
+        super
+      end
+
+      # (see LockerBase#assert!)
+      #
+      # checks that we:
+      #
+      # * we have obtained the lock (i.e. {#locked?} is true)
+      # * have a lock path
+      # * our lock path still exists
+      # * there are no exclusive locks with lower numbers than ours
+      #
+      def assert!
+        super
+      end
+
+      # (see LockerBase#acquirable?)
+      def acquirable?
+        return true   if locked?
+        return false  if blocked_by_semaphore?
+        true
+      rescue Exceptions::NoNode
+        true
+      end
+
+      def blocked_by_semaphore?
+        ( blocking_locks.size >= @semaphore_size )
+      end
+
+      # @private
+      def blocking_locks
+        lower_lock_names
+      end
+
+      # @private
+      def allowed_blocking_locks_remaining
+        @semaphore_size - 1
+      end
+
+      # @private
+      def lock_prefix
+        SEMAPHORE_LOCK_PREFIX
+      end
+
+      def got_semaphore?
+        synchronize { lock_path and not blocked_by_semaphore? }
+      end
+      alias_method :got_lock?, :got_semaphore?
+
+    end # Semaphore
+  end # Locker
+end # ZK

data/lib/zk/locker/shared_locker.rb

@@ -23,98 +23,27 @@ module ZK
         super
       end
 
-      # (see LockerBase#locked?)
-      def locked?
-        false|@locked
-      end
-
       # (see LockerBase#acquirable?)
       def acquirable?
         return true if locked?
-        !lock_children.any? { |n| n.start_with?(EXCLUSIVE_LOCK_PREFIX) }
+        blocking_locks.empty?
       rescue Exceptions::NoNode
         true
       end
 
       # @private
-      def lock_number
-        lock_path and digit_from(lock_path)
-      end
-
-      # returns the sequence number of the next lowest write lock node
-      #
-      # raises NoWriteLockFoundException when there are no write nodes with a 
-      # sequence less than ours
-      #
-      # @private
-      def next_lowest_write_lock_num
-        digit_from(next_lowest_write_lock_name)
-      end
-
-      # the next lowest write lock number to ours
-      #
-      # so if we're "read010" and the children of the lock node are:
-      #
-      #   %w[write008 write009 read010 read011]
-      #
-      # then this method will return write009
-      #
-      # raises NoWriteLockFoundException if there were no write nodes with an
-      # index lower than ours 
-      #
-      # @private
-      def next_lowest_write_lock_name
-        ary = ordered_lock_children()
-        my_idx = ary.index(lock_basename)   # our idx would be 2
-
-        ary[0..my_idx].reverse.find { |n| n.start_with?(EXCLUSIVE_LOCK_PREFIX) }.tap do |rv|
-          raise NoWriteLockFoundException if rv.nil?
+      def lower_write_lock_names
+        lower_lock_names.select do |lock|
+          lock.start_with?(EXCLUSIVE_LOCK_PREFIX)
         end
       end
+      alias :blocking_locks :lower_write_lock_names
 
       # @private
-      def got_read_lock?
-        false if next_lowest_write_lock_num 
-      rescue NoWriteLockFoundException
-        true
+      def lock_prefix
+        SHARED_LOCK_PREFIX
       end
-      alias got_lock? got_read_lock?
-
-      private
-        def lock_with_opts_hash(opts)
-          create_lock_path!(SHARED_LOCK_PREFIX)
-
-          lock_opts = LockOptions.new(opts)
 
-          if got_read_lock?
-            @mutex.synchronize { @locked = true }
-          elsif lock_opts.blocking?
-            block_until_read_lock!(:timeout => lock_opts.timeout)
-          else
-            false
-          end
-        ensure
-          cleanup_lock_path! unless @mutex.synchronize { @locked }
-        end
-
-        def block_until_read_lock!(opts={})
-          begin
-            path = "#{root_lock_path}/#{next_lowest_write_lock_name}"
-            logger.debug { "SharedLocker#block_until_read_lock! path=#{path.inspect}" }
-
-            @mutex.synchronize do
-              @node_deletion_watcher = NodeDeletionWatcher.new(zk, path)
-              @cond.broadcast
-            end
-
-            @node_deletion_watcher.block_until_deleted(opts)
-          rescue NoWriteLockFoundException
-            # next_lowest_write_lock_name may raise NoWriteLockFoundException,
-            # which means we should not block as we have the lock (there is nothing to wait for)
-          end
-
-          @mutex.synchronize { @locked = true }
-        end
     end # SharedLocker
   end # Locker
 end # ZK

data/lib/zk/node_deletion_watcher.rb

@@ -14,11 +14,40 @@ module ZK
     end
     include Constants
 
-    attr_reader :zk, :path
+    attr_reader :zk,
+                :paths,
+                :options,
+                :watched_paths,
+                :remaining_paths,
+                :threshold
+
+    # Create a new NodeDeletionWatcher that has the ability to block until
+    # some or all of the paths given to it have been deleted.
+    #
+    # @param [ZK::client] zk
+    #
+    # @param [Array] paths - one or more paths to watch
+    #
+    # @param optional [Hash] options - Symbol-keyed hash
+    # @option options [Integer,false,nil] :threshold (0)
+    #                           the number of remaining nodes allowed when
+    #                           determining whether or not to continue blocking.
+    #                           If `false` or `nil` are provided, the default
+    #                           will be substituted.
+    #
+    def initialize( zk, paths, options={} )
+      paths = [paths] if paths.kind_of? String # old style single-node support
+
+      @zk         = zk
+      @paths      = paths.dup
+      @options    = options.dup
+      @threshold  = options[:threshold] || 0
+      raise BadArgument, <<-EOBADARG unless @threshold.kind_of? Integer
+        options[:threshold] must be an Integer. Got #{@threshold.inspect}."
+      EOBADARG
 
-    def initialize(zk, path)
-      @zk     = zk
-      @path   = path.dup
+      @watched_paths = []
+      @remaining_paths = paths.dup
 
       @subs   = []
 
@@ -92,25 +121,21 @@ module ZK
     end
 
     # @option opts [Numeric] :timeout (nil) if a positive integer, represents a duration in
-    #   seconds after which, if we have not acquired the lock, a LockWaitTimeoutError will
-    #   be raised in all waiting threads
+    #   seconds after which, if the threshold has not been met, a LockWaitTimeoutError will
+    #   be raised in all waiting threads.
     #
     def block_until_deleted(opts={})
       timeout = opts[:timeout]
 
       @mutex.synchronize do
-        raise InvalidStateError, "Already fired for #{path}" if @result
+        raise InvalidStateError, "Already fired for #{status_string}" if @result
         register_callbacks
 
-        unless zk.exists?(path, :watch => true)
-          # we are done, these are one-shot, so write the results
-          @result = :deleted
-          @blocked = NOT_ANYMORE
-          @cond.broadcast # wake any waiting threads
-          return true
-        end
+        watch_appropriate_nodes
+
+        return finish_blocking if threshold_met?
 
-        logger.debug { "ok, going to block: #{path}" }
+        logger.debug { "ok, going to block: #{status_string}" }
 
         @blocked = BLOCKED
         @cond.broadcast                 # wake threads waiting for @blocked to change
@@ -119,14 +144,15 @@ module ZK
 
         @blocked = NOT_ANYMORE
 
-        logger.debug { "got result for path: #{path}, result: #{@result.inspect}" } 
+        logger.debug { "got result: #{@result.inspect}. #{status_string}" }
 
         case @result
         when :deleted
-          logger.debug { "path #{path} was deleted" }
+          logger.debug { "enough paths were deleted. #{status_string}" }
           return true
         when TIMED_OUT
-          raise ZK::Exceptions::LockWaitTimeoutError, "timed out waiting for #{timeout.inspect} seconds for deletion of path: #{path.inspect}" 
+          raise ZK::Exceptions::LockWaitTimeoutError,
+            "timed out waiting for #{timeout.inspect} seconds for deletion of paths. #{status_string}"
         when INTERRUPTED
           raise ZK::Exceptions::WakeUpException
         when ZOO_EXPIRED_SESSION_STATE
@@ -136,7 +162,7 @@ module ZK
         when ZOO_CLOSED_STATE
           raise Zookeeper::Exceptions::ConnectionClosed
         else
-          raise "Hit unexpected case in block_until_node_deleted, result was: #{@result.inspect}"
+          raise "Hit unexpected case in block_until_node_deleted, result was: #{@result.inspect}. #{status_string}"
         end
       end
     ensure
@@ -144,6 +170,10 @@ module ZK
     end
 
     private
+      def status_string
+        "paths: #{paths.inspect}, remaining: #{remaining_paths.inspect}, options: #{options.inspect}"
+      end
+
       # this method must be synchronized on @mutex, obviously
       def wait_for_result(timeout)
         # do the deadline maths
@@ -172,7 +202,9 @@ module ZK
       end
 
       def register_callbacks
-        @subs << zk.register(path, &method(:node_deletion_cb))
+        paths.each do |path|
+          @subs << zk.register(path, &method(:node_deletion_cb))
+        end
 
         [:expired_session, :connecting, :closed].each do |sym|
           @subs << zk.event_handler.register_state_handler(sym, &method(:session_cb))
@@ -183,14 +215,8 @@ module ZK
         @mutex.synchronize do
           return if @result
 
-          if event.node_deleted?
-            @result = :deleted
-            @cond.broadcast
-          else
-            unless zk.exists?(path, :watch => true)
-              @result = :deleted
-              @cond.broadcast
-            end
+          if event.node_deleted? or not zk.exists?(event.path, :watch => true)
+            finish_node(event.path)
           end
         end
       end
@@ -202,6 +228,36 @@ module ZK
           @cond.broadcast
         end
       end
-  end
-end
 
+      # must be synchronized on @mutex
+      def threshold_met?
+        return true if remaining_paths.size <= threshold
+      end
+
+      # ensures that threshold + 1 nodes are being watched
+      def watch_appropriate_nodes
+        remaining_paths.last( threshold + 1 ).reverse_each do |path|
+          next if watched_paths.include? path
+          watched_paths << path
+          finish_node(path) unless zk.exists?(path, :watch => true)
+        end
+      end
+
+      # must be synchronized on @mutex
+      def finish_blocking
+        @result = :deleted
+        @blocked = NOT_ANYMORE
+        @cond.broadcast # wake any waiting threads
+        true
+      end
+
+      def finish_node(path)
+        remaining_paths.delete path
+        watched_paths.delete   path
+
+        watch_appropriate_nodes
+
+        finish_blocking if threshold_met?
+      end
+  end # MultiNodeDeletionWatcher
+end # ZK

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.8.0"
+  VERSION = "1.9.0"
 end

data/spec/shared/locker_contexts.rb

@@ -9,16 +9,21 @@ shared_context 'locker non-chrooted' do
 
   let(:path) { "lock_path" }
   let(:root_lock_path) { "#{ZK::Locker.default_root_lock_node}/#{path}" }
+  let(:semaphore_root_path) { "#{ZK::Locker::Semaphore.default_root_node}/#{path}" }
 
   before do
     wait_until{ connections.all?(&:connected?) }
     zk.rm_rf(ZK::Locker.default_root_lock_node)
+    zk.rm_rf(ZK::Locker::Semaphore.default_root_node)
   end
 
   after do
     connections.each { |c| c.close! }
     wait_until { !connections.any?(&:connected?) }
-    ZK.open(*connection_args) { |z| z.rm_rf(ZK::Locker.default_root_lock_node) }
+    ZK.open(*connection_args) do |z|
+      z.rm_rf(ZK::Locker.default_root_lock_node)
+      z.rm_rf(ZK::Locker::Semaphore.default_root_node)
+    end
   end
 end
 
@@ -33,6 +38,7 @@ shared_context 'locker chrooted' do
   let(:zk3) { ZK.new("#{connection_host}#{chroot_path}", connection_opts) }
   let(:connections) { [zk, zk2, zk3] }
   let(:root_lock_path) { "#{ZK::Locker.default_root_lock_node}/#{path}" }
+  let(:semaphore_root_path) { "#{ZK::Locker::Semaphore.default_root_node}/#{path}" }
 
   before do
     ZK.open(*connection_args) do |zk|

data/spec/zk/locker/semaphore_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+shared_examples_for 'ZK::Locker::Semaphore' do
+  let(:semaphore_size){ 2 }
+  let(:locker)  { ZK::Locker::Semaphore.new(zk, path, semaphore_size) }
+  let(:locker2) { ZK::Locker::Semaphore.new(zk2, path, semaphore_size) }
+  let(:locker3) { ZK::Locker::Semaphore.new(zk3, path, semaphore_size) }
+
+  describe :assert! do
+    it_should_behave_like 'LockerBase#assert!'
+  end
+
+  describe :acquirable? do
+    describe %[with default options] do
+      it %[should work if the lock root doesn't exist] do
+        zk.rm_rf(ZK::Locker::Semaphore.default_root_node)
+        locker.should be_acquirable
+      end
+
+      it %[should check local state of lockedness] do
+        locker.lock.should be_true
+        locker.should be_acquirable
+      end
+
+      it %[should check if any participants would prevent us from acquiring the lock] do
+        locker3.lock.should be_true
+        locker.should be_acquirable # total locks given less than semaphore_size
+        locker2.lock.should be_true
+        locker.should_not be_acquirable # total locks given equal to semaphore size
+        locker3.unlock
+        locker.should be_acquirable # total locks given less than semaphore_size
+      end
+    end
+  end
+
+  describe :lock do
+    describe 'non-blocking success' do
+      before do
+        @rval   = locker.lock
+        @rval2  = locker2.lock
+      end
+
+      it %[should acquire the first lock] do
+        @rval.should be_true
+        locker.should be_locked
+      end
+
+      it %[should acquire the second lock] do
+        @rval2.should be_true
+        locker2.should be_locked
+      end
+    end
+
+    describe 'non-blocking failure' do
+      before do
+        zk.mkdir_p(semaphore_root_path)
+        semaphore_size.times do
+          zk.create("#{semaphore_root_path}/#{ZK::Locker::SEMAPHORE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
+        end
+        @rval = locker.lock
+      end
+
+      it %[should return false] do
+        @rval.should be_false
+      end
+
+      it %[should not be locked] do
+        locker.should_not be_locked
+      end
+
+      it %[should not have a lock_path] do
+        locker.lock_path.should be_nil
+      end
+    end
+
+    context do
+      before do
+        zk.mkdir_p(semaphore_root_path)
+        @existing_locks = semaphore_size.times.map do
+          zk.create("#{semaphore_root_path}/#{ZK::Locker::SEMAPHORE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
+        end
+        @exc = nil
+      end
+
+      describe 'blocking success' do
+
+        it %[should acquire the lock after the write lock is released] do
+          ary = []
+
+          locker.lock.should be_false
+
+          th = Thread.new do
+            locker.lock(:wait => true)
+            ary << :locked
+          end
+
+          locker.wait_until_blocked(5)
+          locker.should be_waiting
+          locker.should_not be_locked
+          ary.should be_empty
+
+          zk.delete(@existing_locks.shuffle.first)
+
+          th.join(2).should == th
+
+          ary.should_not be_empty
+          ary.length.should == 1
+
+          locker.should be_locked
+        end
+      end
+
+      describe 'blocking timeout' do
+        it %[should raise LockWaitTimeoutError] do
+          ary = []
+
+          write_lock_dir = File.dirname(@existing_locks.first)
+
+          zk.children(write_lock_dir).length.should == semaphore_size
+
+          locker.lock.should be_false
+
+          th = Thread.new do
+            begin
+              locker.lock(:wait => 0.01)
+              ary << :locked
+            rescue Exception => e
+              @exc = e
+            end
+          end
+
+          locker.wait_until_blocked(5)
+          locker.should be_waiting
+          locker.should_not be_locked
+          ary.should be_empty
+
+          th.join(2).should == th
+
+          zk.children(write_lock_dir).length.should == semaphore_size
+
+          ary.should be_empty
+          @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+        end
+
+      end
+    end # context
+  end # lock
+
+  describe :unlock do
+    it_should_behave_like 'LockerBase#unlock'
+  end
+end   # SharedLocker
+
+
+describe do
+  include_context 'locker non-chrooted'
+
+  it_should_behave_like 'ZK::Locker::Semaphore'
+end
+
+describe :chrooted => true do
+  include_context 'locker chrooted'
+
+  it_should_behave_like 'ZK::Locker::Semaphore'
+end

data/spec/zk/locker/shared_exclusive_integration_spec.rb

@@ -42,6 +42,53 @@ shared_examples_for :shared_exclusive_integration do
     end
   end
 
+  describe 'multiple shared locks acquired first' do
+    before do
+      zk3.should_not be_nil
+      @sh_lock2 = ZK::Locker.shared_locker(zk3, path) 
+    end
+    it %[should not aquire a lock when highest-numbered released but others remain] do
+      @sh_lock.lock.should be_true
+      @sh_lock2.lock.should be_true
+      @ex_lock.lock.should be_false
+
+      mutex = Monitor.new
+      cond = mutex.new_cond
+
+      th = Thread.new do
+        logger.debug { "@ex_lock trying to acquire acquire lock" }
+        begin
+          @ex_lock.with_lock(:wait=>0.1) do
+            th[:got_lock] = @ex_lock.locked?
+            logger.debug { "@ex_lock.locked? #{@ex_lock.locked?}" }
+          end
+        rescue ZK::Exceptions::LockWaitTimeoutError
+          logger.debug { "@ex_lock timed out trying to acquire acquire lock" }
+          th[:got_lock] = false
+        rescue
+          logger.debug { "@ex_lock raised unexpected error: #{$!.inspext}" }
+          th[:got_lock] = {:error_raised => $!}
+        end
+        mutex.synchronize { cond.broadcast }
+      end
+
+      mutex.synchronize do
+        @ex_lock.wait_until_blocked(1)
+        logger.debug { "unlocking the highest shared lock" }
+        @sh_lock2.unlock.should be_true
+        cond.wait_until { (!th[:got_lock].nil?) }   # make sure they actually received the lock (avoid race)
+        th[:got_lock].should be_false
+        logger.debug { "they didn't get the lock." }
+      end
+
+      th.join(5).should == th
+
+      logger.debug { "thread joined, exclusive lock should be releasd" }
+      @sh_lock.unlock.should be_true
+      @ex_lock.should_not be_locked
+    end
+  end
+
   describe 'exclusive lock acquired first' do
     it %[should block shared lock from acquiring until released] do
       @ex_lock.lock.should be_true

data/spec/zk/node_deletion_watcher_spec.rb

@@ -86,6 +86,107 @@ describe ZK::NodeDeletionWatcher do
       @n.should be_done
     end
   end
-end
 
+  context %[multiple nodes] do
+    let(:watcher_params){ Hash.new }
+    let(:paths) do
+      [
+        "#{@base_path}/node_deleteion_watcher_victim_one",
+        "#{@base_path}/node_deleteion_watcher_victim_two",
+        "#{@base_path}/node_deleteion_watcher_victim_three"
+      ]
+    end
+    let(:created_paths){ paths }
+    let(:paths_to_delete){ paths }
+    let(:watcher_args) do
+      args = [@zk, paths]
+      args << watcher_params unless watcher_params.nil?
+      args
+    end
+    let(:watcher){ ZK::NodeDeletionWatcher.new(*watcher_args) }
+    subject{ watcher }
 
+    before(:each) do
+      created_paths.each do |path|
+        @zk.mkdir_p(path)
+      end
+    end
+
+    let(:watcher_block_params){ Hash.new }
+    let(:watcher_wait_timeout){ 5 }
+
+    let(:runner) do
+      Thread.new do
+        Thread.pass
+        begin
+          watcher.block_until_deleted( watcher_block_params )
+        rescue Object
+          @exc = $!
+        end
+      end
+    end
+
+    let(:controller) do
+      Thread.new do
+        Thread.pass
+        watcher.wait_until_blocked( watcher_wait_timeout )
+        paths_to_delete.each do |path|
+          @zk.rm_rf(path)
+        end
+      end
+    end
+
+    it 'should block until all are deleted' do
+      runner.run
+      controller.run
+      controller.join
+      runner.join(5).should == runner
+      watcher.should be_done
+    end
+
+    context %[threshold not supplied] do
+      let(:watcher_params){}
+
+      it 'should raise' do
+        expect{ watcher }.to_not raise_exception
+      end
+      its(:threshold){ should be_zero }
+    end
+
+    context %[invalid threshold given] do
+      let(:watcher_params){ {:threshold => :foo} }
+      it 'should raise' do
+        expect{ watcher }.to raise_exception
+      end
+    end
+
+    context %[threshold of 1] do
+      let(:watcher_params) { { :threshold => 1 } }
+      context do
+        let(:paths_to_delete) { paths.first(2) }
+        it 'should release when 1 remains' do
+          runner.run
+          controller.run
+          controller.join
+          runner.join(5).should == runner
+          watcher.should be_done
+        end
+        its(:threshold){ should == 1 }
+      end
+
+      context do
+        let(:paths_to_delete) { paths.first(1) }
+        let(:watcher_block_params){ { :timeout => 0.02 } }
+        it 'should raise when 2 remain' do
+          runner.run
+          controller.run
+          controller.join
+          runner.join(5).should == runner
+          @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+          watcher.should be_done
+          watcher.should be_timed_out
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 51
   prerelease: 
   segments: 
   - 1
-  - 8
+  - 9
   - 0
-  version: 1.8.0
+  version: 1.9.0
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-19 00:00:00 Z
+date: 2013-08-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper
@@ -64,6 +64,8 @@ extra_rdoc_files: []
 files: 
 - .dotfiles/ctags_paths
 - .dotfiles/rspec-logging
+- .dotfiles/ruby-gemset
+- .dotfiles/ruby-version
 - .dotfiles/rvmrc
 - .gitignore
 - .gitmodules
@@ -101,6 +103,7 @@ files:
 - lib/zk/locker/exclusive_locker.rb
 - lib/zk/locker/lock_options.rb
 - lib/zk/locker/locker_base.rb
+- lib/zk/locker/semaphore.rb
 - lib/zk/locker/shared_locker.rb
 - lib/zk/logging.rb
 - lib/zk/message_queue.rb
@@ -146,6 +149,7 @@ files:
 - spec/zk/extensions_spec.rb
 - spec/zk/locker/exclusive_locker_spec.rb
 - spec/zk/locker/locker_basic_spec.rb
+- spec/zk/locker/semaphore_spec.rb
 - spec/zk/locker/shared_exclusive_integration_spec.rb
 - spec/zk/locker/shared_locker_spec.rb
 - spec/zk/locker_spec.rb
@@ -224,6 +228,7 @@ test_files:
 - spec/zk/extensions_spec.rb
 - spec/zk/locker/exclusive_locker_spec.rb
 - spec/zk/locker/locker_basic_spec.rb
+- spec/zk/locker/semaphore_spec.rb
 - spec/zk/locker/shared_exclusive_integration_spec.rb
 - spec/zk/locker/shared_locker_spec.rb
 - spec/zk/locker_spec.rb