zk-eventmachine 0.1.1

data/.dev_extras/README

@@ -0,0 +1,5 @@
+A small place to hide goodies that I use while developing this 
+
+slyphon-project.vimrc is a local .vimrc file with abbrevs. 
+rvmrc is my .rvmrc
+

data/.dev_extras/rspec

@@ -0,0 +1 @@
+--color

data/.dev_extras/rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2

data/.dev_extras/slyphon-project.vimrc

@@ -0,0 +1,18 @@
+iabbr _ZEM ZK::ZKEventMachine
+iabbr _ZCB ZK::ZKEventMachine::Callback
+iabbr _ZCLI ZK::ZKEventMachine::Client
+
+iabbr _wia i.with_indifferent_access
+iabbr _lam lambda {}hi
+
+iabbr _seq i.should ==
+iabbr _srex i.should raise_exception()i
+iabbr _srexarg i.should raise_exception(ArgumentError)i
+iabbr _snrex i.should_not raise_exception
+iabbr _sbnil i.should be_nil
+
+iabbr _desc describe do
+iabbr _bef before do
+
+
+" vim:ft=vim

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+.vimrc
+.rspec
+*.log

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+source 'http://localhost:50000'
+
+
+# Specify your gem's dependencies in zk-em.gemspec
+gemspec
+
+
+# vim:ft=ruby

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Hewlett Packard Development Company, L.P.
+
+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.markdown

@@ -0,0 +1,8 @@
+## OMG!
+
+[ZK][] client implementation for [EventMachine][]
+
+
+[ZK]: https://github.com/slyphon/zk
+[EventMachine]: https://github.com/eventmachine/eventmachine
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/z_k/z_k_event_machine/callback.rb

@@ -0,0 +1,256 @@
+module ZK
+  module ZKEventMachine
+    # some improvements (one hopes) around the zookeeper gem's somewhat (ahem)
+    # minimal Callback class
+    #
+    module Callback
+      
+      # Used by ZooKeeper to return an asynchronous result. 
+      #
+      # If callbacks or errbacks are set on the instance, they will be called
+      # with just the data returned from the call (much like their synchronous
+      # versions). 
+      #
+      # If a block was given to #new or #on_result, then that block is called
+      # with a ZK::Exceptions::KeeperException instance or nil, then the rest
+      # of the arguments defined for that callback type
+      #
+      # the node-style and deferred-style results are *NOT* exclusive, so if
+      # you use both _you will be called with results in both formats_.
+      #
+      class Base
+        include Deferred
+        include ZK::Logging
+
+        # set the result keys that should be used by node_style_result and to
+        # call the deferred_style_result blocks
+        #
+        def self.async_result_keys(*syms)
+          if syms.empty? 
+            @async_result_keys || []
+          else
+            @async_result_keys = syms.map { |n| n.to_sym }
+          end
+        end
+
+        def initialize(prok=nil, &block)
+          on_result(prok, &block)
+        end
+
+        # register a block that should be called (node.js style) with the
+        # results
+        #
+        # @note replaces the block given to #new 
+        #
+        def on_result(prok=nil, &block)
+          @block = (prok || block)
+        end
+
+        # Checks the return code from the async call. If the return code was not ZOK,
+        # then fire the errbacks and do the node-style error call
+        # otherwise, does nothing
+        def check_async_rc(hash)
+          call(hash) unless success?(hash)
+        end
+
+        # ZK will call this instance with a hash of data, which is the result
+        # of the asynchronous call. Depending on the style of callback in use,
+        # we take the appropriate actions
+        #
+        # delegates to #deferred_style_result and #node_style_result
+        def call(hash)
+#           logger.debug { "#{self.class.name}#call hash: #{hash.inspect}" }
+          EM.schedule do
+            deferred_style_result(hash) 
+            node_style_result(hash)
+          end
+        end
+
+        # returns true if the request was successful (if return_code was Zookeeper::ZOK)
+        #
+        # @param [Hash] hash the result of the async call 
+        # 
+        # @returns [true, false] for success, failure 
+        def success?(hash)
+          hash[:rc] == Zookeeper::ZOK
+        end
+
+        # Returns an instance of a sublcass ZK::Exceptions::KeeperException
+        # based on the asynchronous return_code.
+        #
+        # facilitates using case statements for error handling
+        #
+        # @param [Hash] hash the result of the async call 
+        #
+        # @raise [RuntimeError] if the return_code is not known by ZK (this should never
+        #   happen and if it does, you should report a bug)
+        #
+        # @return [ZK::Exceptions::KeeperException, nil] subclass based on
+        #   return_code if there was an error, nil otherwise
+        #
+        def exception_for(hash)
+          return nil if success?(hash)
+          return_code = hash.fetch(:rc)
+          ZK::Exceptions::KeeperException.by_code(return_code).new
+        end
+
+        # @abstract should call set_deferred_status with the appropriate args
+        #   for the result and type of call
+        def deferred_style_result(hash)
+          # ensure this calls the callback on the reactor
+
+          if success?(hash)
+            vals = hash.values_at(*async_result_keys)
+#             logger.debug { "#{self.class.name}#deferred_style_result async_result_keys: #{async_result_keys.inspect}, vals: #{vals.inspect}" }
+            self.succeed(*hash.values_at(*async_result_keys))
+          else
+            self.fail(exception_for(hash))
+          end
+        end
+
+        # call the user block with the correct Exception class as the first arg
+        # (or nil if no error) and then the appropriate args for the type of
+        # asynchronous call
+        def node_style_result(hash)
+          return unless @block
+          vals = hash.values_at(*async_result_keys)
+#           logger.debug { "#{self.class.name}#node_style_result async_result_keys: #{async_result_keys.inspect}, vals: #{vals.inspect}" }
+          if exc = exception_for(hash)
+            @block.call(exc)
+          else
+            @block.call(nil, *vals)
+          end
+        end
+
+        protected
+          def async_result_keys
+            self.class.async_result_keys
+          end
+      end
+
+      # used with Client#get call
+      class DataCallback < Base
+        async_result_keys :data, :stat
+      end
+
+      # used with Client#children call
+      class ChildrenCallback < Base
+        async_result_keys :strings, :stat
+      end
+
+      # used with Client#create
+      class StringCallback < Base
+        async_result_keys :string
+      end
+
+      # used with Client#stat and Client#exists?
+      class StatCallback < Base
+        async_result_keys :stat
+
+        # stat has a different concept of 'success', stat on a node that doesn't 
+        # exist is not an exception, it's a certain kind of stat (like a null stat).
+        def success?(hash)
+          rc = hash[:rc] 
+          (rc == Zookeeper::ZOK) || (rc == Zookeeper::ZNONODE)
+        end
+      end
+
+      # supports the syntactic sugar exists? call
+      class ExistsCallback < StatCallback
+        async_result_keys :stat
+
+        # @abstract should call set_deferred_status with the appropriate args
+        #   for the result and type of call
+        def deferred_style_result(hash)
+          # ensure this calls the callback on the reactor
+
+          if success?(hash)
+            succeed(hash[:stat].exists?)
+          else
+            fail(exception_for(hash))
+          end
+        end
+
+        # call the user block with the correct Exception class as the first arg
+        # (or nil if no error) and then the appropriate args for the type of
+        # asynchronous call
+        def node_style_result(hash)
+          return unless @block
+          @block.call(exception_for(hash), hash[:stat].exists?)
+        end
+      end
+
+      # set operation returns a stat object, but in this case a NONODE is an
+      # error (unlike with StatCallback)
+      class SetCallback < Base
+        async_result_keys :stat
+      end
+
+      # used with Client#delete and Client#set_acl
+      class VoidCallback < Base
+      end
+
+      # used with Client#get_acl
+      class ACLCallback < Base
+        async_result_keys :acl, :stat
+      end
+
+      class << self
+        def new_data_cb(njs_block)
+          DataCallback.new(njs_block).tap do |cb| # create the callback with the user-provided block
+            cb.check_async_rc(yield(cb))          # yield the callback to the caller, check the return result 
+                                                  # of the async operation (not the async result)
+          end                                     # return the callback
+        end
+        alias :new_get_cb :new_data_cb    # create alias so that this matches the client API name
+
+        def new_string_cb(njs_block)
+          StringCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+        alias :new_create_cb :new_string_cb
+
+        def new_stat_cb(njs_block)
+          StatCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+
+        def new_exists_cb(njs_block)
+          ExistsCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+
+        def new_set_cb(njs_block)
+          SetCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+
+        def new_void_cb(njs_block)
+          VoidCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+        alias :new_delete_cb :new_void_cb
+        alias :new_set_acl_cb :new_void_cb
+
+        def new_children_cb(njs_block)
+          ChildrenCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+
+        def new_acl_cb(njs_block)
+          ACLCallback.new(njs_block).tap do |cb|
+            cb.check_async_rc(yield(cb))
+          end
+        end
+        alias :new_get_acl_cb :new_acl_cb
+      end
+    end
+  end
+end
+

data/lib/z_k/z_k_event_machine/client.rb

@@ -0,0 +1,122 @@
+module ZK
+  module ZKEventMachine
+    class Client < ZK::Client::Base
+      include ZK::Logging
+      include Unixisms
+
+      DEFAULT_TIMEOUT = 10
+
+      attr_reader :client
+
+      # Takes same options as ZK::Client::Base
+      def initialize(host, opts={})
+        @host = host
+        @close_deferred = Deferred::Default.new
+        @event_handler = EventHandlerEM.new(self)
+      end
+
+      def on_close(&blk)
+        @close_deferred.callback(&blk) if blk
+        @close_deferred
+      end
+
+      # open a ZK connection, attach it to the reactor. 
+      # returns an EM::Deferrable that will be called when the connection is
+      # ready for use
+      def connect(&blk)
+        # XXX: maybe move this into initialize, need to figure out how to schedule it properly
+        @cnx ||= ZookeeperEM::Client.new(@host, DEFAULT_TIMEOUT, event_handler.get_default_watcher_block).tap do |c|
+          c.on_attached { logger.debug { "connection is attached" } }
+        end
+
+        @cnx.on_attached(&blk)
+      end
+
+      def reopen(*a)
+        raise NotImplementedError, "reoopen is not implemented for the eventmachine version of the client"
+      end
+      
+      def close!(&blk)
+        on_close(&blk)
+
+        if @cnx
+          logger.debug { "#{self.class.name}: calling @cnx.close" }
+          @cnx.close
+          @cnx = nil
+
+          logger.debug { "#{self.class.name}: @cnx.close callback fired, clearing event_handler" }
+          event_handler.clear!
+          logger.debug { "firing on_close handler" }
+          on_close.succeed
+        else
+          on_close.succeed
+        end
+
+        on_close
+      end
+      alias :close :close!
+
+      # get data at path, optionally enabling a watch on the node
+      #
+      # @returns [Callback] returns a Callback which is an EM::Deferred (so you
+      #   can assign callbacks/errbacks) see Callback::Base for discussion
+      #
+      def get(path, opts={}, &block)
+        Callback.new_get_cb(block) do |cb|
+          super(path, opts.merge(:callback => cb))
+        end
+      end
+
+      def create(path, data='', opts={}, &block)
+        Callback.new_create_cb(block) do |cb|
+          super(path, data, opts.merge(:callback => cb))
+        end
+      end
+
+      def set(path, data, opts={}, &block)
+        Callback.new_set_cb(block) do |cb|
+          super(path, data, opts.merge(:callback => cb))
+        end
+      end
+
+      def stat(path, opts={}, &block)
+        cb_style = opts.delete(:cb_style) { |_| 'stat' }
+
+        meth = :"new_#{cb_style}_cb"
+
+        Callback.__send__(meth, block) do |cb|
+          super(path, opts.merge(:callback => cb))
+        end
+      end
+
+      def exists?(path, opts={}, &block)
+        stat(path, opts.merge(:cb_style => 'exists'), &block)
+      end
+
+      def delete(path, opts={}, &block)
+        Callback.new_delete_cb(block) do |cb|
+          super(path, opts.merge(:callback => cb))
+        end
+      end
+
+      def children(path, opts={}, &block)
+        Callback.new_children_cb(block) do |cb|
+          super(path, opts.merge(:callback => cb))
+        end
+      end
+
+      def get_acl(path, opts={}, &block)
+        Callback.new_get_acl_cb(block) do |cb|
+          super(path, opts.merge(:callback => cb))
+        end
+      end
+
+      def set_acl(path, acls, opts={}, &block)
+        Callback.new_set_acl_cb(block) do |cb|
+          super(path, acls, opts.merge(:callback => cb))
+        end
+      end
+    end
+  end
+end
+

data/lib/z_k/z_k_event_machine/deferred.rb

@@ -0,0 +1,39 @@
+module ZK
+  module ZKEventMachine
+    module Deferred
+      include EM::Deferrable
+
+      # slight modification to EM::Deferrable, 
+      #
+      # @returns [self] to allow for chaining
+      #
+      def callback(&block)
+        super(&block)
+        self
+      end
+
+      # @see #callback
+      def errback(&block)
+        super(&block)
+        self
+      end
+
+      # adds the block to both the callback and errback chains
+      def ensure_that(&block)
+        callback(&block)
+        errback(&block)
+      end
+
+      def chain_to(other_dfr, opts={})
+        other_dfr.callback { |*a| self.succeed(*a) }
+        other_dfr.errback { |*a| self.fail(*a) } unless opts[:ignore_errors]
+        self
+      end
+
+      class Default
+        include ZK::ZKEventMachine::Deferred
+      end
+    end
+  end
+end
+

data/lib/z_k/z_k_event_machine/event_handler_e_m.rb

@@ -0,0 +1,34 @@
+module ZK
+  module ZKEventMachine
+    # a small wrapper around the EventHandler instance, allowing us to 
+    # deliver the event on the reactor thread, as opposed to calling it directly
+    #
+    class EventHandlerEM < ZK::EventHandler
+      include ZK::Logging
+
+      def register(path, &block)
+        # use the supplied block, but ensure that it gets called on the reactor
+        # thread
+        new_blk = lambda do |*a|
+          EM.schedule { block.call(*a) }
+        end
+
+        super(path, &new_blk)
+      end
+      alias :subscribe :register
+
+      def process(event)
+        EM.schedule { super(event) }
+      end
+
+      protected
+        # we're running on the Reactor, don't need to synchronize (hah, hah, we'll see...)
+        #
+        def synchronize
+          yield
+        end
+    end
+  end
+end
+
+