zk-eventmachine 0.1.13 → 0.2.0.beta.1

data/.gitignore

@@ -7,4 +7,3 @@ pkg/*
 .rspec
 *.log
 .yardoc
-doc

data/Gemfile

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

data/Rakefile

@@ -1,37 +1,2 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
-
-task :yard do
-  Bundler.setup
-  require 'yard'
-
-  YARD::Rake::YardocTask.new(:run_yardoc) do |t|
-    t.files = ['lib/**/*.rb']
-  end
-
-  Rake::Task[:run_yardoc].invoke
-end
-
-%w[1.8.7 1.9.2 1.9.3 jruby].each do |rvm_ruby|
-  gemset_name         = 'zk-em'
-  ruby_with_gemset    = "#{rvm_ruby}@#{gemset_name}"
-  create_gemset_name  = "mb:#{rvm_ruby}:create_gemset"
-  bundle_task_name    = "mb:#{rvm_ruby}:bundle_install"
-  rspec_task_name     = "mb:#{rvm_ruby}:run_rspec"
-
-  task create_gemset_name do
-    sh "rvm #{rvm_ruby} do rvm gemset create #{gemset_name}" 
-  end
-
-  task bundle_task_name => create_gemset_name do
-    rm_f 'Gemfile.lock'
-    sh "rvm #{ruby_with_gemset} do bundle install"
-  end
-
-  task rspec_task_name => bundle_task_name do
-    sh "rvm #{ruby_with_gemset} do bundle exec rspec spec --fail-fast"
-  end
-
-  task 'mb:test_all' => rspec_task_name
-end
-

data/lib/z_k/z_k_event_machine/callback.rb

@@ -70,7 +70,7 @@ module ZK
         #
         # @param [Hash] hash the result of the async call 
         # 
-        # @return [true, false] for success, failure 
+        # @returns [true, false] for success, failure 
         def success?(hash)
           hash[:rc] == Zookeeper::ZOK
         end

data/lib/z_k/z_k_event_machine/client.rb

@@ -1,63 +1,26 @@
 module ZK
   module ZKEventMachine
     class Client < ZK::Client::Base
-      include Deferred::Accessors
       include ZK::Logging
       include Unixisms
 
       DEFAULT_TIMEOUT = 10
 
-      # If we get a ZK::Exceptions::ConnectionLoss exeption back from any call,
-      # or a EXPIRED_SESSION_STATE event, we will call back any handlers registered
-      # here with the exception instance as the argument.
-      #
-      # once this deferred has been fired, it will be replaced with a new
-      # deferred, so callbacks must be re-registered, and *should* be
-      # re-registered *within* the callback to avoid missing events
-      # 
-      # @method on_connection_lost
-      # @return [Deferred::Default]
-      deferred_event :connection_lost
-      
-
-      # Registers a one-shot callback for the ZOO_CONNECTED_STATE event. 
-      #
-      # @note this is experimental currently. This may or may not fire for the *initial* connection.
-      # it's purpose is to warn an already-existing client with watches that a connection has been
-      # re-established (with session information saved). From the ZooKeeper Programmers' Guide:
-      #
-      #   If you are using watches, you must look for the connected watch event.
-      #   When a ZooKeeper client disconnects from a server, you will not receive
-      #   notification of changes until reconnected. If you are watching for a
-      #   znode to come into existance, you will miss the event if the znode is
-      #   created and deleted while you are disconnected.
-      #
-      # once this deferred has been fired, it will be replaced with a new
-      # deferred, so callbacks must be re-registered, and *should* be
-      # re-registered *within* the callback to avoid missing events
-      #
-      # @method on_connected
-      # @return [Deferred::Default]
-      deferred_event :connected
-
-      # Registers a one-shot callback for the ZOO_CONNECTING_STATE event
-      #
-      # This event is triggered when we have become disconnected from the
-      # cluster and are in the process of reconnecting.
-      deferred_event :connecting
-
-      # called back once the connection has been closed.
-      #
-      # @method on_close
-      # @return [Deferred::Default]
-      deferred_event :close
+      # allows the synchrony client to muck with this
+      # @private
+      attr_writer :event_handler
 
       # Takes same options as ZK::Client::Base
       def initialize(host, opts={})
         @host = host
-        @event_handler  = EventHandlerEM.new(self)
-        @closing        = false
-        register_default_event_handlers!
+        @close_deferred = Deferred::Default.new
+        @connection_lost_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. 
@@ -65,21 +28,34 @@ module ZK
       # 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)
-        )
+        @cnx ||= ZookeeperEM::Client.new(@host, DEFAULT_TIMEOUT, event_handler.get_default_watcher_block)
         @cnx.on_attached(&blk)
       end
 
       # @private
+      # XXX: move this down into ZK::Client::Base
+      def connected?
+        @cnx and @cnx.connected?
+      end
+
+      # If we get a ZK::Exceptions::ConnectionLoss exeption back from any call,
+      # we will call back any handlers registered here with the exception
+      # instance as the argument
+      #
+      # once this deferred has been fired, it will be replaced with a new
+      # deferred, so callbacks must be re-registered
+      # 
+      def on_connection_lost(&blk)
+        @connection_lost_deferred.callback(&blk) if blk
+        @connection_lost_deferred
+      end
+
       def reopen(*a)
         raise NotImplementedError, "reoopen is not implemented for the eventmachine version of the client"
       end
       
       def close!(&blk)
         on_close(&blk)
-        return on_close if @closing
-        @closing = true
 
         if @cnx
           logger.debug { "#{self.class.name}: in close! clearing event_handler" }
@@ -101,7 +77,7 @@ module ZK
 
       # get data at path, optionally enabling a watch on the node
       #
-      # @return [Callback] returns a Callback which is an EM::Deferred (so you
+      # @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)
@@ -168,47 +144,11 @@ module ZK
         end
       end
 
-      # @return [Fixnum] The underlying connection's session_id
-      def session_id
-        return nil unless @cnx
-        @cnx.session_id
-      end
-
-      # @return [String] The underlying connection's session passwd (an opaque value)
-      def session_passwd
-        return nil unless @cnx
-        @cnx.session_passwd
-      end
-
     protected
-      # @private
-      def register_default_event_handlers!
-        @event_handler.register_state_handler(Zookeeper::ZOO_EXPIRED_SESSION_STATE, &method(:handle_expired_session_state_event!))
-        @event_handler.register_state_handler(Zookeeper::ZOO_CONNECTED_STATE,       &method(:handle_connected_state_event!))
-        @event_handler.register_state_handler(Zookeeper::ZOO_CONNECTING_STATE,      &method(:handle_connecting_state_event!))
-      end
-
-      # @private
-      def handle_connected_state_event!(event)
-        reset_connected_event.succeed(event)
-      end
-
-      # @private
-      def handle_connecting_state_event!(event)
-        reset_connecting_event.succeed(event)
-      end
-
-      # @private
-      def handle_expired_session_state_event!(event)
-        exc = ZK::Exceptions::ConnectionLoss.new("Received EXPIRED_SESSION_STATE event: #{event.inspect}")
-        exc.set_backtrace(caller)
-        connection_lost_hook(exc)
-      end
-
-      # @private
       def connection_lost_hook(exc)
         if exc and exc.kind_of?(ZK::Exceptions::ConnectionLoss)
-          reset_connection_lost_event.succeed(exc)
+          dfr, @connection_lost_deferred = @connection_lost_deferred, Deferred::Default.new
+          dfr.succeed(exc)
         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/synchrony_client.rb

@@ -0,0 +1,111 @@
+module ZK
+  module ZKEventMachine
+    class SynchronyEventHandlerWrapper
+      include ZK::Logging
+
+      def initialize(event_handler)
+        @event_handler = event_handler
+      end
+
+      # registers a block to be called back within a fiber context
+      def register(path, &block)
+        new_block = proc do |*a|
+          Fiber.new { block.call(*a) }.resume
+        end
+
+        @event_handler.register(path, &new_block)
+      end
+
+      private
+        def method_missing(meth, *a, &b)
+          @event_handler.__send__(meth, *a, &b)
+        end
+    end
+
+    # This class is an EM::Synchrony wrapper around a ZK::ZKEventMachine::Client
+    #
+    # It should behave exactly like a ZK::Client instance (when called in a
+    # synchronous fashion), and one should look there for documentation about
+    # the various methods
+    #
+    # @note this class is implemented as a wrapper instead of a subclass of Client
+    #   so that it can support the unixisms like rm_rf and mkdir_p. The
+    #   synchrony pattern of aliasing the base class methods and specializing for 
+    #   synchrony didn't work in this case.
+    #
+    class SynchronyClient
+      include ZK::Logging
+
+      attr_reader :event_handler, :client
+
+      # @overload new(client_instance)
+      #   Wrap an existing ZK::ZKEventMachine::Client instance in an
+      #   EM::Synchrony compatible way
+      #   @param [ZK::ZKEventMachine::Client] client_instance an instance of Client to wrap
+      # @overload new(host, opts={})
+      #   Creates a new ZK::ZKEventMachine::Client instance to manage
+      #   takes the same arguments as ZK::Client::Base
+      def initialize(host, opts={})
+        case host
+        when Client
+          @client = host
+        when String
+          @client = Client.new(host, opts)
+        else
+          raise ArgumentError, "argument must be either a ZK::ZKEventMachine::Client instance or a hostname:port string"
+        end
+
+        @event_handler = SynchronyEventHandlerWrapper.new(@client.event_handler)
+      end
+
+      %w[connect close close! get set create stat delete children get_acl set_acl mkdir_p rm_rf].each do |meth|
+        class_eval(<<-EOMETH, __FILE__, __LINE__ + 1)
+          def #{meth}(*args,&blk)
+            sync!(@client.#{meth}(*args, &blk))
+          end
+        EOMETH
+      end
+
+      # @deprecated for backwards compatibility only
+      def watcher
+        event_handler
+      end
+
+      def exists?(path, opts={})
+        stat(path, opts={}).exists?
+      end
+
+      protected
+        # a modification of EM::Synchrony.sync to handle multiple callback arguments properly
+        def sync(df)
+          f = Fiber.current
+
+          xback = proc do |*args|
+            if f == Fiber.current
+              return *args
+            else
+              f.resume(*args)
+            end
+          end
+
+          df.callback(&xback)
+          df.errback(&xback)
+
+          Fiber.yield
+        end
+
+        # like sync, but if the deferred returns an exception instance, re-raises
+        def sync!(deferred)
+          rval = sync(deferred)
+          raise rval if rval.kind_of?(Exception)
+          rval
+        end
+
+      private
+        def method_missing(meth, *a, &b)
+          @client.__send__(meth, *a, &b)
+        end
+    end
+  end
+end
+

data/lib/z_k/z_k_event_machine/unixisms.rb

@@ -31,18 +31,15 @@ module ZK
         _handle_calling_convention(dfr, &blk)
       end
 
-      # @private
       def find(*paths, &block)
         raise NotImplementedError, "Coming soon"
       end
 
-      # @private
       def block_until_node_deleted(abs_node_path)
         raise NotImplementedError, "blocking does not make sense in EventMachine-land"
       end
 
       protected
-        # @private
         def _handle_calling_convention(dfr, &blk)
           return dfr unless blk
           dfr.callback { |*a| blk.call(nil, *a) }
@@ -50,7 +47,6 @@ module ZK
           dfr
         end
 
-        # @private
         def _rm_rf_dfr(path)
           Deferred::Default.new.tap do |my_dfr|
             delete(path) do |exc|
@@ -89,7 +85,6 @@ module ZK
           end
         end
 
-        # @private
         def _mkdir_p_dfr(path)
           Deferred::Default.new.tap do |my_dfr|
             d = create(path, '')

data/lib/z_k/z_k_event_machine/version.rb

@@ -1,5 +1,5 @@
 module ZK
   module ZKEventMachine
-    VERSION = "0.1.13"
+    VERSION = "0.2.0.beta.1"
   end
 end

data/lib/z_k/z_k_event_machine.rb

@@ -1,10 +1,11 @@
 require 'eventmachine'
+require 'em-synchrony'
 
 require 'zookeeper'
 require 'zookeeper/em_client'
 
 require 'zk'
-require 'deferred'
+
 
 module ZK
   module ZKEventMachine
@@ -15,9 +16,11 @@ end
 $LOAD_PATH.unshift(File.expand_path('../..', __FILE__)).uniq!
 
 require 'z_k/z_k_event_machine/iterator'
+require 'z_k/z_k_event_machine/deferred'
 require 'z_k/z_k_event_machine/callback'
 require 'z_k/z_k_event_machine/event_handler_e_m'
 require 'z_k/z_k_event_machine/unixisms'
 require 'z_k/z_k_event_machine/client'
+require 'z_k/z_k_event_machine/synchrony_client'
 
 

data/spec/spec_helper.rb

@@ -10,6 +10,8 @@ require 'evented-spec'
 # in spec/support/ and its subdirectories.
 Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
 
+$stderr.sync = true
+
 case `uname -s`.chomp
 when 'Linux'
   $stderr.puts "WARN: setting EM.epoll = true for tests"
@@ -19,25 +21,6 @@ when 'Darwin'
   EM.kqueue = true
 end
 
-# method to wait until block passed returns true or timeout (default is 2 seconds) is reached 
-def wait_until(timeout=2)
-  time_to_stop = Time.now + timeout
-
-  until yield 
-    break if Time.now > time_to_stop
-    Thread.pass
-  end
-end
-
-def wait_while(timeout=2)
-  time_to_stop = Time.now + timeout
-
-  while yield 
-    break if Time.now > time_to_stop
-    Thread.pass
-  end
-end
-
 RSpec.configure do |config|
   config.mock_with :flexmock
 end

data/spec/support/logging.rb

@@ -1,19 +1,14 @@
 require 'logger'
 
-log_file = File.open(File.expand_path('../../../test.log', __FILE__), 'a').tap { |f| f.sync = true }
+logger = Logger.new(File.expand_path('../../../test.log', __FILE__)).tap {|l| l.level = Logger::DEBUG}
 
-Logger.new(log_file).tap do |log| 
-  log.level = Logger::DEBUG 
-  ZK.logger = log
-  Zookeeper.logger = log
-end
-
-# for debugging along with C output uncomment the following
-#
-# $stderr.sync = true
 # logger = Logger.new($stderr).tap { |l| l.level = Logger::DEBUG }
 # Zookeeper.set_debug_level(4)
 
+ZK.logger = logger
+Zookeeper.logger = ZK.logger
+
+
 def logger
   ZK.logger
 end