zk 1.3.1 → 1.4.0

data/.yardopts

@@ -1,6 +1,8 @@
 --no-private
 --tag hidden_example:Hidden
+--tag hidden_option:Hidden
 --hide-tag hidden_example
+--hide-tag hidden_option
 --markup markdown
 -
 LICENSE

data/README.markdown

@@ -8,6 +8,8 @@ ZK is licensed under the [MIT][] license.
 
 The key place to start in the documentation is with ZK::Client::Base ([rubydoc.info][ZK::Client::Base], [local](/docs/ZK/Client/Base)).
 
+See the [RELEASES][] file for information on what changed between versions.
+
 This library is heavily used in a production deployment and is actively developed and maintained.
 
 Development is sponsored by [Snapfish][] and has been generously released to the Open Source community by HPDC, L.P.
@@ -17,6 +19,7 @@ Development is sponsored by [Snapfish][] and has been generously released to the
 [zookeeper gem]: https://github.com/slyphon/zookeeper "slyphon-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
 
 ## What is ZooKeeper? ##
 
@@ -63,6 +66,27 @@ In addition to all of that, I would like to think that the public API the ZK::Cl
 
 ## NEWS ##
 
+### v1.4.0 ###
+
+* Added a new `:ignore` option for convenience when you don't care if an operation fails. In the case of a failure, the method will return nil instead of raising an exception. This option works for `children`, `create`, `delete`, `get`, `get_acl`, `set`, and `set_acl`. `stat` will ignore the option (because it doesn't care about the state of a node).
+
+```
+# so instead of having to do:
+
+begin
+  zk.delete('/some/path')
+rescue ZK::Exceptions;:NoNode
+end
+
+# you can do
+
+zk.delete('/some/path', :ignore => :no_node)
+
+```
+
+* MASSIVE fork/parent/child test around event delivery and much greater stability expected for linux (with the zookeeper-1.0.3 gem). Again, please see the documentation on the wiki about [proper fork procedure](http://github.com/slyphon/zk/wiki/Forking).
+
+
 ### v1.3.1 ###
 
 * [fix a bug][bug 1.3.1] where a forked client would not have its 'outstanding watches' cleared, so some events would never be delivered
@@ -96,13 +120,6 @@ You are __STRONGLY ENCOURAGED__ to go and look at the [CHANGELOG](http://git.io/
 * Fixed a race condition in `event_catcher_spec.rb` that would cause 100% cpu usage and hang.
 
 
-### v1.1.0 ###
-
-* NEW! Thread-per-Callback event delivery model! [Read all about it!](https://github.com/slyphon/zk/wiki/EventDeliveryModel). Provides a simple, sane way to increase the concurrency in your ZK-based app while maintaining the ordering guarantees ZooKeeper makes. Each callback can perform whatever work it needs to without blocking other callbacks from receiving events. Inspired by [Celluloid's](https://github.com/celluloid/celluloid) actor model.
-
-* Use the [zk-server](https://github.com/slyphon/zk-server) gem to run a standalone ZooKeeper server for tests (`rake SPAWN_ZOOKEEPER=1`). Makes live-fire testing of any project that uses ZK easy to run anywhere!
-
-
 ## Caveats
 
 ZK strives to be a complete, correct, and convenient way of interacting with ZooKeeper. There are a few things to be aware of:

data/RELEASES.markdown

@@ -1,4 +1,25 @@
 This file notes feature differences and bugfixes contained between releases. 
+
+### v1.4.0 ###
+
+* Added a new `:ignore` option for convenience when you don't care if an operation fails. In the case of a failure, the method will return nil instead of raising an exception. This option works for `children`, `create`, `delete`, `get`, `get_acl`, `set`, and `set_acl`. `stat` will ignore the option (because it doesn't care about the state of a node).
+
+```
+# so instead of having to do:
+
+begin
+  zk.delete('/some/path')
+rescue ZK::Exceptions;:NoNode
+end
+
+# you can do
+
+zk.delete('/some/path', :ignore => :no_node)
+
+```
+
+* MASSIVE fork/parent/child test around event delivery and much greater stability expected for linux (with the zookeeper-1.0.3 gem). Again, please see the documentation on the wiki about [proper fork procedure](http://github.com/slyphon/zk/wiki/Forking).
+
 ### v1.3.1 ###
 
 * [fix a bug][bug 1.3.1] where a forked client would not have its 'outstanding watches' cleared, so some events would never be delivered

data/lib/zk/client/base.rb

@@ -43,8 +43,8 @@ module ZK
     #
     class Base
       # The Eventhandler is used by client code to register callbacks to handle
-      # events triggerd for given paths. 
-      #
+      # events triggered for given paths. 
+      # 
       # @see ZK::Client::Base#register
       attr_reader :event_handler
       
@@ -53,6 +53,17 @@ module ZK
       attr_reader :cnx
       protected :cnx
 
+      # maps from a symbol given as an option, to the numeric error constant that should
+      # not raise an exception
+      #
+      # @private
+      ERROR_IGNORE_MAP = {
+        :no_node      => Zookeeper::ZNONODE,
+        :node_exists  => Zookeeper::ZNODEEXISTS,
+        :not_empty    => Zookeeper::ZNOTEMPTY,
+        :bad_version  => Zookeeper::ZBADVERSION,
+      }
+
       # @deprecated for backwards compatibility only
       # use ZK::Client::Base#event_handler instead
       def watcher
@@ -125,6 +136,12 @@ module ZK
       #
       def close!
         event_handler.clear!
+        close
+      end
+
+      # close the underlying connection, but do not reset callbacks registered
+      # via the `register` method. This is to be used when preparing to fork.
+      def close
         wrap_state_closed_error { cnx.close if cnx && !cnx.closed? }
       end
 
@@ -177,29 +194,58 @@ module ZK
       #   creates a znode at the absolute `path` with blank data and given
       #   options
       #
+      #   @option opts [Zookeeper::Callbacks::StringCallback] :callback (nil) provide a callback object
+      #     that will be called when the znode has been created
+      #   
+      #   @option opts [Object] :context (nil) an object passed to the `:callback`
+      #     given as the `context` param
+      #
+      #   @option opts [:ephemeral_sequential, :persistent_sequential, :persistent, :ephemeral] :mode (nil)
+      #     may be specified instead of :ephemeral and :sequence options. If `:mode` *and* either of
+      #     the `:ephermeral` or `:sequential` options are given, the `:mode` option will win
+      #
+      #   @option opts [:no_node,:node_exists] :ignore (nil) Do not raise an error if
+      #     one of the given statuses is returned from ZooKeeper. This option
+      #     may be given as either a symbol (for a single option) or as an Array
+      #     of symbols for multiple ignores. This is useful when you want to
+      #     create a node but don't care if it's already been created, and don't
+      #     want to have to wrap it in a begin/rescue/end block.
+      #
+      #     * `:no_node`: silences the error case where you try to
+      #       create `/foo/bar/baz` but any of the parent paths (`/foo` or
+      #       `/foo/bar`) don't exist. 
+      #
+      #     * `:node_exists`: silences the error case where you try to create
+      #       `/foo/bar` but it already exists.
+      #
       # @overload create(path, data, opts={})
       #   creates a znode at the absolute `path` with given data and options
       # 
-      # @option opts [Integer] :acl defaults to <tt>Zookeeper::Constants::ZOO_OPEN_ACL_UNSAFE</tt>, 
-      #   otherwise the ACL for the node. Should be a `ZOO_*` constant defined under the 
-      #   Zookeeper::ACLs module in the zookeeper gem.
+      #   @option opts [Zookeeper::Callbacks::StringCallback] :callback (nil) provide a callback object
+      #     that will be called when the znode has been created
+      #   
+      #   @option opts [Object] :context (nil) an object passed to the `:callback`
+      #     given as the `context` param
       #
-      # @option opts [bool] :ephemeral (false) if true, the created node will be ephemeral
+      #   @option opts [:ephemeral_sequential, :persistent_sequential, :persistent, :ephemeral] :mode (nil)
+      #     may be specified instead of :ephemeral and :sequence options. If `:mode` *and* either of
+      #     the `:ephermeral` or `:sequential` options are given, the `:mode` option will win
       #
-      # @option opts [bool] :sequence (false) if true, the created node will be sequential
+      #   @option opts [:no_node,:node_exists] :ignore (nil) Do not raise an error if
+      #     one of the given statuses is returned from ZooKeeper. This option
+      #     may be given as either a symbol (for a single option) or as an Array
+      #     of symbols for multiple ignores. This is useful when you want to
+      #     create a node but don't care if it's already been created, and don't
+      #     want to have to wrap it in a begin/rescue/end block.
       #
-      # @option opts [bool] :sequential (false) alias for :sequence option. if both are given
-      #   an ArgumentError is raised
+      #     * `:no_node`: silences the error case where you try to
+      #       create `/foo/bar/baz` but any of the parent paths (`/foo` or
+      #       `/foo/bar`) don't exist. 
       #
-      # @option opts [Zookeeper::Callbacks::StringCallback] :callback (nil) provide a callback object
-      #   that will be called when the znode has been created
-      # 
-      # @option opts [Object] :context (nil) an object passed to the `:callback`
-      #   given as the `context` param
+      #     * `:node_exists`: silences the error case where you try to create
+      #       `/foo/bar` but it already exists.
       #
-      # @option opts [:ephemeral_sequential, :persistent_sequential, :persistent, :ephemeral] :mode (nil)
-      #   may be specified instead of :ephemeral and :sequence options. If `:mode` *and* either of
-      #   the `:ephermeral` or `:sequential` options are given, the `:mode` option will win
+      # @since 1.4.0: `:ignore` option
       #
       # @raise [ZK::Exceptions::NodeExists] if a node with the same `path` already exists
       # 
@@ -208,7 +254,9 @@ module ZK
       # @raise [ZK::Exceptions::NoChildrenForEphemerals] if the parent node of
       #   the given path is ephemeral
       #
-      # @return [String] the path created on the server
+      # @return [String] if created successfully the path created on the server
+      #
+      # @return [nil] if :ignore option is given and one of the errors listed 
       #
       # @todo Document the asynchronous methods
       #
@@ -325,7 +373,7 @@ module ZK
           end
         end
 
-        rv = check_rc(cnx.create(h), h)
+        rv = call_and_check_rc(:create, h)
 
         h[:callback] ? rv : rv[:path]
       end
@@ -386,7 +434,7 @@ module ZK
         h = { :path => path }.merge(opts)
 
         rv = setup_watcher!(:data, h) do
-          check_rc(cnx.get(h), h)
+          call_and_check_rc(:get, h)
         end
 
         opts[:callback] ? rv : rv.values_at(:data, :stat)
@@ -427,6 +475,24 @@ module ZK
       # @option opts [Object] :context an object passed to the `:callback`
       #   given as the `context` param
       #
+      # @option opts [:no_node,:bad_version] :ignore (nil) Do not raise an error if
+      #   one of the given statuses is returned from ZooKeeper. This option
+      #   may be given as either a symbol (for a single option) or as an Array
+      #   of symbols for multiple ignores. This is useful when you want to
+      #   set a node if it exists but don't care if it doesn't.
+      #
+      #   * `:no_node`: silences the error case where you try to
+      #     set `/foo/bar/baz` but it doesn't exist.
+      #
+      #   * `:bad_version`: silences the error case where you give a `:version`
+      #     but it doesn't match the server's version. 
+      #
+      # @since 1.4.0: `:ignore` option
+      #
+      # @return [Stat] the stat of the node after a successful update
+      #
+      # @return [nil] if `:ignore` is given and our update was not successful
+      #
       # @example unconditionally set the data of "/path"
       #
       #   zk.set("/path", "foo")
@@ -435,25 +501,59 @@ module ZK
       #
       #   zk.set("/path", "foo", :version => 0)
       #
+      # @example set the data of a non-existent node, check for success
+      #   
+      #   if zk.set("/path/does/not/exist", 'blah', :ignore => :no_node)
+      #     puts 'the node existed and we updated it to say "blah"'
+      #   else
+      #     puts "pffft, i didn't wanna update that stupid node anyway"
+      #   end
+      #
+      # @example fail to set the data of a node, ignore bad_version
+      # 
+      #   data, stat = zk.get('/path')
+      #
+      #   if zk.set("/path", 'blah', :version => stat.version, :ignore => :bad_version)
+      #     puts 'the node existed, had the right version, and we updated it to say "blah"'
+      #   else
+      #     puts "guess someone beat us to it"
+      #   end
+      #
+      # @hidden_example set data asynchronously
+      #
+      #   class StatCallback
+      #     def process_result(return_code, path, context, stat)
+      #       # do processing here
+      #     end
+      #   end
+      #  
+      #   callback = StatCallback.new
+      #   context = Object.new
+      #
+      #   zk.set("/path", "foo", :callback => callback, :context => context)
+      #
       def set(path, data, opts={})
-        # ===== set data asynchronously
-        #
-        #   class StatCallback
-        #     def process_result(return_code, path, context, stat)
-        #       # do processing here
-        #     end
-        #   end
-        #  
-        #   callback = StatCallback.new
-        #   context = Object.new
-        #
-        #   zk.set("/path", "foo", :callback => callback, :context => context)
-
         h = { :path => path, :data => data }.merge(opts)
 
-        rv = check_rc(cnx.set(h), h)
+        rv = call_and_check_rc(:set, h)
 
-        opts[:callback] ? rv : rv[:stat]
+        logger.debug { "rv: #{rv.inspect}" }
+
+        # the reason we check the :rc here is: if the user set an :ignore which
+        # has successfully squashed an error code from turning into an exception
+        # we want to return nil. If the user was successful, we want to return
+        # the Stat we got back from the server
+        #
+        # in the case of an async request, we want to return the result code of
+        # the async operation (the submission)
+        
+        if opts[:callback]
+          rv 
+        elsif (rv[:rc] == Zookeeper::ZOK)
+          rv[:stat]
+        else
+          nil
+        end
       end
 
       # Return the stat of the node of the given path. Return nil if the node
@@ -556,11 +656,19 @@ module ZK
       # @option opts [bool] :watch (false) set to true if you want your registered
       #   callbacks for this node to be called on change
       #
-      # @option opts [Zookeeper::Callbacks::StringsCallback] :callback to make this
+      # @hidden_option opts [Zookeeper::Callbacks::StringsCallback] :callback to make this
       #   call asynchronously
       #
-      # @option opts [Object] :context an object passed to the `:callback`
+      # @hidden_option opts [Object] :context an object passed to the `:callback`
       #   given as the `context` param
+      #
+      # @option opts [:no_node] :ignore (nil) Do not raise an error if
+      #   one of the given statuses is returned from ZooKeeper. This option
+      #   may be given as either a symbol (for a single option) or as an Array
+      #   of symbols for multiple ignores. 
+      #
+      #   * `:no_node`: silences the error case where you try to
+      #     set `/foo/bar/baz` but it doesn't exist.
       # 
       # @example get children for path
       #
@@ -577,24 +685,24 @@ module ZK
       #   zk.children("/path", :watch => true)
       #   # => ["child_0", "child_1"]
       #
+      # @hidden_example
+      #
+      #   class ChildrenCallback
+      #     def process_result(return_code, path, context, children)
+      #       # do processing here
+      #     end
+      #   end
+      #  
+      #   callback = ChildrenCallback.new
+      #   context = Object.new
+      #   zk.children("/path", :callback => callback, :context => context)
+      #
       def children(path, opts={})
-        # ===== get children asynchronously
-        #
-        #   class ChildrenCallback
-        #     def process_result(return_code, path, context, children)
-        #       # do processing here
-        #     end
-        #   end
-        #  
-        #   callback = ChildrenCallback.new
-        #   context = Object.new
-        #   zk.children("/path", :callback => callback, :context => context)
-
 
         h = { :path => path }.merge(opts)
 
         rv = setup_watcher!(:child, h) do
-          check_rc(cnx.get_children(h), h)
+          call_and_check_rc(:get_children, h)
         end
 
         opts[:callback] ? rv : rv[:children]
@@ -629,6 +737,24 @@ module ZK
       #
       # @option opts [Object] :context an object passed to the `:callback`
       #   given as the `context` param
+      #
+      # @option opts [:no_node,:not_empty,:bad_version] :ignore (nil) Do not
+      #   raise an error if one of the given statuses is returned from ZooKeeper.
+      #   This option may be given as either a symbol (for a single option) or as
+      #   an Array of symbols for multiple ignores. This is useful when you want
+      #   to delete a node but don't care if it's already been deleted, and don't
+      #   want to have to wrap it in a begin/rescue/end block.
+      #
+      #   * `:no_node`: silences the error case where you try to
+      #     delete `/foo/bar/baz` but it doesn't exist.
+      #
+      #   * `:not_empty`: silences the error case where you try to delete
+      #     `/foo/bar` but it has children.
+      #
+      #   * `:bad_version`: silences the error case where you give a `:version`
+      #     but it doesn't match the server's version. 
+      #
+      # @since 1.4.0: `:ignore` option
       # 
       # @example delete a node
       #   zk.delete("/path")
@@ -636,23 +762,22 @@ module ZK
       # @example delete a node with a specific version
       #   zk.delete("/path", :version => 5)
       #
+      # @hidden_example
+      #
+      #   class VoidCallback
+      #     def process_result(return_code, path, context)
+      #       # do processing here
+      #     end
+      #   end
+      #  
+      #   callback = VoidCallback.new
+      #   context = Object.new
+      #
+      #   zk.delete(/path", :callback => callback, :context => context)
+      #
       def delete(path, opts={})
-        # ===== delete node asynchronously
-        #
-        #   class VoidCallback
-        #     def process_result(return_code, path, context)
-        #       # do processing here
-        #     end
-        #   end
-        #  
-        #   callback = VoidCallback.new
-        #   context = Object.new
-        #
-        #   zk.delete(/path", :callback => callback, :context => context)
-
-
         h = { :path => path, :version => -1 }.merge(opts)
-        rv = check_rc(cnx.delete(h), h)
+        rv = call_and_check_rc(:delete, h)
         opts[:callback] ? rv : nil
       end
 
@@ -684,21 +809,21 @@ module ZK
       #   zk.get_acl("/path", :stat => stat)
       #   # => [ACL]
       #
+      # @hidden_example
+      #
+      #   class AclCallback
+      #     def processResult(return_code, path, context, acl, stat)
+      #       # do processing here
+      #     end
+      #   end
+      #  
+      #   callback = AclCallback.new
+      #   context = Object.new
+      #   zk.acls("/path", :callback => callback, :context => context)
+      #
       def get_acl(path, opts={})
-        # ===== get acl asynchronously
-        #
-        #   class AclCallback
-        #     def processResult(return_code, path, context, acl, stat)
-        #       # do processing here
-        #     end
-        #   end
-        #  
-        #   callback = AclCallback.new
-        #   context = Object.new
-        #   zk.acls("/path", :callback => callback, :context => context)
-
         h = { :path => path }.merge(opts)
-        rv = check_rc(cnx.get_acl(h), h)
+        rv = call_and_check_rc(:get_acl, h)
         opts[:callback] ? rv : rv.values_at(:children, :stat)
       end
 
@@ -729,7 +854,7 @@ module ZK
       #
       def set_acl(path, acls, opts={})
         h = { :path => path, :acl => acls }.merge(opts)
-        rv = check_rc(cnx.set_acl(h), h)
+        rv = call_and_check_rc(:set_acl, h)
         opts[:callback] ? rv : rv[:stat]
       end
 
@@ -780,9 +905,18 @@ module ZK
       # to remove the block from further updates by calling its `.unsubscribe` method.
       #
       # You can specify a list of event types after the path that you wish to
-      # receive in your block. This allows you to register different blocks for
-      # different types of events.
-      #
+      # receive in your block using the `:only` option. This allows you to
+      # register different blocks for different types of events. This sounds
+      # more convenient, but __there is a potential pitfall__. The `:only`
+      # option does filtering behind the scenes, so if you need a `:created`
+      # event, but a `:changed` event is delivered instead, *and you don't have
+      # a handler registered* for the `:changed` event which re-watches, then
+      # you will most likely just miss it and blame the author. You should try
+      # to stick to the style where you use a single block to test for the
+      # different event types, re-registering as necessary. If you find that
+      # block gets too out of hand, then use the `:only` option and break the
+      # logic up between handlers.
+      # 
       # @note All node watchers are one-shot handlers. After an event is delivered to
       #   your handler, you *must* re-watch the node to receive more events. This
       #   leads to a pattern you will find throughout ZK code that avoids races,
@@ -899,15 +1033,53 @@ module ZK
           Process.pid != @pid
         end
 
+        def call_and_check_rc(meth, opts)
+          scrubbed_opts = opts.dup
+          scrubbed_opts.delete(:ignore)
+
+          rv = cnx.__send__(meth, scrubbed_opts)
+
+          check_rc(rv, opts)
+        end
+
         # @private
-        def check_rc(hash, inputs=nil)
-          code = hash[:rc]
+        # XXX: make this actually call the method on cnx
+        def check_rc(rv_hash, inputs)
+          code   = rv_hash[:rc]
+
           if code && (code != Zookeeper::ZOK)
+            return rv_hash if ignore_set(inputs[:ignore]).include?(code)
+            
             msg = inputs ? "inputs: #{inputs.inspect}" : nil
             raise Exceptions::KeeperException.by_code(code), msg 
           else
-            hash
+            rv_hash
+          end
+        end
+
+        # arg is either a symbol (for one ignore) or an array
+        # this method checks for validity, returns a set of the integers that
+        # can be ignored or the empty set if arg is nil
+        def ignore_set(arg)
+          return Set.new if arg.nil?
+
+          sym_array =
+            case arg
+            when Symbol
+              [arg]
+            when Array
+              arg
+            else
+              raise ArgumentError, ":ignore option needs to be one of: #{ERROR_IGNORE_MAP.keys.inspect}, as a symbol or array of symbols, not #{arg.inspect}" 
+            end
+
+          bad_keys = sym_array - ERROR_IGNORE_MAP.keys
+
+          unless bad_keys.empty?
+            raise ArgumentError, "Sorry, #{bad_keys.inspect} not valid for :ignore, valid arguments are: #{ERROR_IGNORE_MAP.keys.inspect}"
           end
+
+          Set.new(ERROR_IGNORE_MAP.values_at(*sym_array))
         end
 
         # @private

data/lib/zk/client/threaded.rb

@@ -221,6 +221,11 @@ module ZK
         nil
       end
 
+      # {see Base#close}
+      def close
+        super
+      end
+
       # (see Threadpool#on_threadpool?)
       def on_threadpool?
         @threadpool and @threadpool.on_threadpool?

data/lib/zk/event_handler.rb

@@ -44,15 +44,44 @@ module ZK
         h.tap { |x| x[k] = Set.new }
       end
 
+      @state = :running
+
       reopen_after_fork!
     end
+
+    # stops the dispatching of events. already in-flight callbacks may still be running, but
+    # no new events will be dispatched until {#start} is called
+    #
+    # any events that are delivered while we are stopped will be lost
+    #
+    def stop
+      synchronize do
+        return if @state == :stopped
+        @state = :stopped
+      end
+    end
+
+    # called to re-enable event delivery
+    def start
+      synchronize do
+        return if @state == :running
+        @state = :running
+      end
+    end
+
+    def running?
+      synchronize { @state == :running }
+    end
+
+    def stopped?
+      synchronize { @state == :stopped }
+    end
     
     # do not call this method. it is inteded for use only when we've forked and 
     # all other threads are dead.
     #
     # @private
     def reopen_after_fork!
-      logger.debug { "#{self.class}##{__method__} reopening callbacks" }
       @mutex = Monitor.new
       # XXX: need to test this w/ actor-style callbacks
       @callbacks.values.flatten.each { |cb| cb.reopen_after_fork! if cb.respond_to?(:reopen_after_fork!) }

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/spec/shared/client_contexts.rb

@@ -1,6 +1,6 @@
 shared_context 'connection opts' do
   let(:connection_opts) { { :thread => :per_callback, :timeout => 5 } }
-  let(:connection_host) { "localhost:#{ZK.test_port}" }
+  let(:connection_host) { "#{ZK.default_host}:#{ZK.test_port}" }
   let(:connection_args) { [connection_host, connection_opts] }
 end
 

data/spec/shared/client_examples.rb

@@ -102,13 +102,48 @@ shared_examples_for 'client' do
     it %[should barf if both :sequence and :sequential are given] do
       lambda { @zk.create(@base_path, 'data', :sequence => true, :sequential => true) }.should raise_error(ArgumentError)
     end
+
+    describe %[:ignore option] do
+      it %[should squelch node_exists] do
+        @zk.create(@base_path)
+
+        proc { @zk.create(@base_path, :ignore => :node_exists).should be_nil }.should_not raise_error(ZK::Exceptions::NoNode)
+      end
+
+      it %[should squelch no_node] do
+        proc { @zk.create("#{@base_path}/foo/bar/baz", :ignore => :no_node).should be_nil }.should_not raise_error(ZK::Exceptions::NoNode)
+      end
+    end
+  end
+
+  describe :delete do
+    describe %[:ignore option] do
+      it %[should squelch not_empty] do
+        @zk.create(@base_path)
+        @zk.create("#{@base_path}/blah")
+
+        proc { @zk.delete(@base_path, :ignore => :not_empty).should be_nil }.should_not raise_error
+      end
+
+      it %[should squelch no_node] do
+        proc { @zk.delete("#{@base_path}/foo/bar/baz", :ignore => :no_node).should be_nil }.should_not raise_error
+      end
+
+      it %[should squelch bad_version] do
+        @zk.create(@base_path)
+        proc { @zk.delete("#{@base_path}", :version => 7, :ignore => :bad_version).should be_nil }.should_not raise_error
+      end
+    end
   end
 
   describe :stat do
     describe 'for a missing node' do
       before do
         @missing_path = '/thispathdoesnotexist'
-        @zk.delete(@missing_path) rescue ZK::Exceptions::NoNode
+        begin
+          @zk.delete(@missing_path) 
+        rescue ZK::Exceptions::NoNode
+        end
       end
 
       it %[should not raise any error] do
@@ -125,6 +160,19 @@ shared_examples_for 'client' do
     end
   end
 
+  describe :set do
+    describe %[:ignore option] do
+      it %[should squelch no_node] do
+        proc { @zk.set("#{@base_path}/foo/bar/baz", '', :ignore => :no_node).should be_nil }.should_not raise_error
+      end
+
+      it %[should squelch bad_version] do
+        @zk.create(@base_path)
+        proc { @zk.set("#{@base_path}", '', :version => 7, :ignore => :bad_version).should be_nil }.should_not raise_error
+      end
+    end
+  end
+
   describe :block_until_node_deleted do
     before do
       @path = '/_bogualkjdhsna'

data/spec/support/00_test_port_attr.rb

@@ -16,5 +16,10 @@ module ZK
   # argh, blah, this affects ZK.new everywhere (which is kind of the point, but
   # still gross)
   self.default_port = self.test_port
+
+  # only for testing is this done
+  if host = ENV['ZK_DEFAULT_HOST']
+    self.default_host = host
+  end
 end
 

data/spec/zk/client_spec.rb

@@ -60,59 +60,128 @@ describe ZK::Client::Threaded do
         ZK.open(*connection_args) { |z| z.rm_rf(@base_path) }
       end
 
-      it %[should deliver callbacks in the child] do
-        pending_in_travis "skip this test, flaky in travis"
-        pending_rbx('fails in rubinius') do
+      it %[should deliver callbacks in the child], :fork => true do
+#         pending_in_travis "skip this test, flaky in travis"
+        pending_rbx('fails in rubinius')
         
-          logger.debug { "Process.pid of parent: #{Process.pid}" }
-
-          @zk = ZK.new do |z|
-            z.on_connected do
-              logger.debug { "on_connected fired, writing pid to path #{@pids_root}/#{$$}" }
-              begin
-                z.create("#{@pids_root}/#{Process.pid}", Process.pid.to_s)
-              rescue ZK::Exceptions::NodeExists
+        logger.debug { "Process.pid of parent: #{Process.pid}" }
+
+        @zk = ZK.new do |z|
+          z.on_connected do
+            logger.debug { "on_connected fired, writing pid to path #{@pids_root}/#{$$}" }
+            begin
+              z.create("#{@pids_root}/#{Process.pid}", Process.pid.to_s)
+            rescue ZK::Exceptions::NodeExists
+            end
+          end
+        end
+
+        @parent_pid = $$
+        
+        @zk.create("#{@pids_root}/#{$$}", $$.to_s)
+
+        event_catcher = EventCatcher.new
+
+        @zk.register(@pids_root) do |event|
+          if event.node_child?
+            event_catcher << event
+          else
+            @zk.children(@pids_root, :watch => true)
+          end
+        end
+
+        logger.debug { "parent watching for children on #{@pids_root}" }
+        @zk.children(@pids_root, :watch => true)  # side-effect, register watch
+
+        @pid = fork do
+          @zk.reopen
+          @zk.wait_until_connected
+
+          child_pid_path = "#{@pids_root}/#{$$}"
+
+          create_latch = Zookeeper::Latch.new
+
+          create_sub = @zk.register(child_pid_path) do |event|
+            if event.node_created?
+              logger.debug { "got created event, releasing create_latch" }
+              create_latch.release
+            else
+              if @zk.exists?(child_pid_path, :watch => true)
+                logger.debug { "created behind our backs, releasing create_latch" }
+                create_latch.release 
               end
             end
           end
 
-          @parent_pid = $$
+          if @zk.exists?(child_pid_path, :watch => true)
+            logger.debug { "woot! #{child_pid_path} exists!" }
+            create_sub.unregister
+          else
+            logger.debug { "awaiting the create_latch to release" }
+            create_latch.await
+          end
+
+          logger.debug { "now testing for delete event totally created in child" }
 
-          @zk.create("#{@pids_root}/#{$$}", $$.to_s)
+          delete_latch = Zookeeper::Latch.new
 
-          event_catcher = EventCatcher.new
+          delete_event = nil
 
-          @zk.register(@pids_root, :only => :child) do |event|
-            event_catcher << event
+          delete_sub = @zk.register(child_pid_path) do |event|
+            if event.node_deleted?
+              delete_event = event
+              logger.debug { "child got delete event on #{child_pid_path}" }
+              delete_latch.release
+            else
+              unless @zk.exists?(child_pid_path, :watch => true)
+                logger.debug { "child: someone deleted #{child_pid_path} behind our back" }
+                delete_latch.release 
+              end
+            end
           end
 
-          @pid = fork do
-            @zk.reopen
-            @zk.wait_until_connected
+          @zk.exists?(child_pid_path, :watch => true)
+
+          @zk.delete(child_pid_path)
 
-            wait_until(3) { @zk.exists?("#{@pids_root}/#{$$}") }
+          logger.debug { "awaiting deletion event notification" }
+          delete_latch.await unless delete_event
 
-            logger.debug { "in child: child pid path exists?: %p" % [@zk.exists?("#{@pids_root}/#{$$}")] }
+          logger.debug { "deletion event: #{delete_event}" }
 
+          if delete_event
             exit! 0
+          else
+            exit! 1
           end
+        end
 
-          _, stat = Process.wait2(@pid)
+        # replicates deletion watcher inside child
+        child_pid_path = "#{@pids_root}/#{@pid}"
 
-          stat.should_not be_signaled
-          stat.should be_exited
-          stat.should be_success
+        delete_latch = Latch.new
 
-          event_catcher.synchronize do
-            unless event_catcher.child.empty?
-              event_catcher.wait_for_child
-              event_catcher.child.should_not be_empty
+        delete_sub = @zk.register(child_pid_path) do |event|
+          if event.node_deleted?
+            logger.debug { "parent got delete event on #{child_pid_path}" }
+            delete_latch.release
+          else
+            unless @zk.exists?(child_pid_path, :watch => true)
+              logger.debug { "child: someone deleted #{child_pid_path} behind our back" }
+              delete_latch.release
             end
           end
+        end
+
+        delete_latch.await if @zk.exists?(child_pid_path, :watch => true)
+
+        _, stat = Process.wait2(@pid)
+
+        stat.should_not be_signaled
+        stat.should be_exited
+        stat.should be_success
 
-          @zk.should be_exists("#{@pids_root}/#{@pid}")
 
-        end
       end # should deliver callbacks in the child
     end # forked
   end # # jruby guard

data/zk.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{A high-level wrapper around the zookeeper driver}
   s.description = s.summary + "\n"
 
-  s.add_runtime_dependency 'zookeeper', '~> 1.0.2'
+  s.add_runtime_dependency 'zookeeper', '~> 1.0.3'
   s.add_runtime_dependency 'backports', '~> 2.5.1'
 
   s.files         = `git ls-files`.split("\n")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 7
   prerelease: 
   segments: 
   - 1
-  - 3
-  - 1
-  version: 1.3.1
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-09 00:00:00 Z
+date: 2012-05-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 17
         segments: 
         - 1
         - 0
-        - 2
-        version: 1.0.2
+        - 3
+        version: 1.0.3
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency