zkruby 3.4.3 → 3.4.4.rc3

data/lib/zkruby/enum.rb

@@ -50,13 +50,13 @@ module Enumeration
 
     module ClassMethods
       
-        # @param [] ref Symbol, Fixnum or Enumeration
+        # @param [Symbol,Fixnum,Enumeration] ref 
         # @return [Enumeration] instance representing ref or nil if not found
         def get(ref)
             @enums[ref]
         end
 
-        # @param [] ref Symbol, Fixnum 
+        # @param [Symbol,Fixnum] ref 
         # @raise [KeyError] if ref not found
         # @return [Enumeration] 
         def fetch(ref)

data/lib/zkruby/eventmachine.rb

@@ -4,7 +4,8 @@ if defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /1\.6\.5.*/
     raise "Fibers are broken in JRuby 1.6.5 (See JRUBY-6170)"
 end
 
-require 'strand'
+# Tell Strand that we want to consider event machine
+Strand.reload()
 
 module ZooKeeper
     module EventMachine
@@ -13,6 +14,7 @@ module ZooKeeper
             include Protocol
             include Slf4r::Logger        
 
+            attr_reader :session
             unless EventMachine.methods.include?(:set_pending_connect_timeout)
                 def set_pending_connect_timeout(timeout)
 
@@ -20,6 +22,7 @@ module ZooKeeper
             end  
 
             def initialize(session,connect_timeout)
+                @fiber = Fiber.current
                 @session = session
                 @connect_timeout = connect_timeout
                 set_pending_connect_timeout(connect_timeout)
@@ -27,39 +30,60 @@ module ZooKeeper
                 logger.warn("Exception in initialize",ex)
             end
 
-            def post_init()
-            rescue Exception => ex
-                logger.warn("Exception in post_init",ex)
-            end
+            # This "loop" is a means of keeping all the session activity
+            # on the session strand
+            def read_loop()
+                event,*args = Fiber.yield
+                if (event == :connection_completed)
+                    logger.debug("Connection completed")
+                    session.prime_connection(self)
 
-            def connection_completed()
-                @session.prime_connection(self)
-
-                # Make sure we connect within the timeout period
-                # TODO this should really be the amount of connect timeout left over
-                @timer = EM.add_timer(@connect_timeout) do
-                    if @session.connected?
-                        # Start the ping timer 
-                        ping = @session.ping_interval 
-                        @timer = EM.add_periodic_timer ( ping ) do
-                            case @ping
-                            when 1 then @session.ping()
-                            when 2 then close_connection()
+                    @timer = EM.add_timer(@connect_timeout) do
+                        @fiber.resume(:connect_timer)
+                    end
+
+                    ping = 0
+                    # If session sleeps or waits in here then our yield/resumes are going to get out of sync
+                    while true
+                        event,*args = Fiber.yield
+                        case event
+                        when :connect_timer
+                            if session.connected?
+                                @timer = EM.add_periodic_timer(session.ping_interval) do
+                                    @fiber.resume(:ping_timer)
+                                end
+                            else
+                                close_connection()
+                            end
+                        when :ping_timer
+                            case ping
+                            when 1 then session.ping
+                            when 2 then close_connection
                             end
-                            @ping += 1
+                            ping += 1
+                        when :receive_records
+                            packet_io = args[0]
+                            ping = 0
+                            session.receive_records(packet_io)
+                        when :unbind
+                            break
                         end
-                    else
-                        close_connection()
                     end
                 end
+                EM.cancel_timer(@timer) if @timer
+                session.disconnected
+            end
 
+            def connection_completed()
+                @fiber.resume(:connection_completed)
             rescue Exception => ex
-                logger.warn("Exception in connection_completed",ex)
+                logger.error("Exception in connection_completed",ex)
             end
 
             def receive_records(packet_io)
-                @ping = 0
-                @session.receive_records(packet_io)
+                @fiber.resume(:receive_records,packet_io)
+            rescue Exception => ex
+                logger.error("Exception in receive_records",ex)
             end
 
             def disconnect()
@@ -67,120 +91,19 @@ module ZooKeeper
             end
 
             def unbind
-                EM.cancel_timer(@timer) if @timer
-                @session.disconnected()
+                @fiber.resume(:unbind)
             rescue Exception => ex
-                logger.warn("Exception in unbind",ex)
+                logger.error("Exception in unbind",ex)
             end
 
         end
 
-
-        # The EventMachine binding is very simple because there is only one thread!
-        # and we have good stuff like timers provided for us
-        class Binding
-            include Slf4r::Logger        
-            # We can use this binding if we are running in the reactor thread
-            def self.available?()
-                EM.reactor_running? && EM.reactor_thread?
+        module Binding
+            def connect(host,port,timeout)
+                conn = EM.connect(host,port,ZooKeeper::EventMachine::ClientConn,self,timeout)
+                conn.read_loop
             end
-
-            def self.context(&context_block)
-                s = Strand.new() do
-                    context_block.call(Strand)
-                end
-                s.join
-            end
-
-            attr_reader :client, :session
-            def start(client,session)
-                @client = client
-                @session = session
-                @session.start()
-            end
-
-            def connect(host,port,delay,timeout)
-                EM.add_timer(delay) do
-                    EM.connect(host,port,ZooKeeper::EventMachine::ClientConn,@session,timeout)
-                end
-            end
-
-            # You are working in event machine it is up to you to ensure your callbacks do not block
-            def invoke(callback,*args)
-                callback.call(*args)
-            end
-
-            def queue_request(*args,&callback)
-                op = AsyncOp.new(self,&callback)
-                begin
-                    @session.queue_request(*args) do |error,response|
-                        op.resume(error,response)
-                    end
-                rescue ZooKeeper::Error => ex
-                    op.resume(ex,nil)
-                end
-
-                op
-            end
-
-            def close(&callback)
-
-                op = AsyncOp.new(self,&callback)
-
-                begin
-                    @session.close() do |error,response|
-                        op.resume(error,response) 
-                    end
-                rescue ZooKeeper::Error => ex
-                    op.resume(ex,nil)
-                end
-
-                op
-            end
-
         end #class Binding
 
-        class AsyncOp < ZooKeeper::AsyncOp
-
-            def initialize(binding,&callback)
-                @em_binding = binding
-
-                # Wrap the callback in its own Strand
-                @op_strand = Strand.new do
-                    #immediately pause
-                    error, response = Strand.yield
-                    Strand.current[ZooKeeper::CURRENT] =  [ @em_binding.client ] 
-                    raise error if error
-                    callback.call(response)
-                end
-            end
-
-            def resume(error,response)
-                #TODO - raise issue in strand for resume to take arguments
-                op_strand.fiber.resume(error,response)
-            end
-
-            private
-
-            attr_reader :op_strand,:err_strand
-
-            def set_error_handler(errcallback)
-                @err_strand = Strand.new() do
-                    begin
-                        op_strand.value()
-                    rescue StandardError => ex
-                        Strand.current[ZooKeeper::CURRENT] =  [ @em_binding.client ] 
-                        errcallback.call(ex)   
-                    end
-                end
-            end
-
-            def wait_value()
-                err_strand ? err_strand.value : op_strand.value 
-            end
-
-        end #class AsyncOp
     end #module EventMachine
 end #module ZooKeeper
-
-ZooKeeper.add_binding(ZooKeeper::EventMachine::Binding)

data/lib/zkruby/protocol.rb

@@ -5,46 +5,46 @@ module ZooKeeper
     # client's shouldn't see this
     class ProtocolError < IOError;end
 
-     # Raw object protocol, very similar to EM's native ObjectProtocol
-     # Expects:
-     #   #receive_data and #send_records to be invoked
-     #   #receive_records and #send_data to be implemented
-     module Protocol
+    # Raw object protocol, very similar to EM's native ObjectProtocol
+    # Expects:
+    #   #receive_data and #send_records to be invoked
+    #   #receive_records and #send_data to be implemented
+    module Protocol
         MIN_PACKET = 5 #TODO Work out what the min packet size really is
         include Slf4r::Logger
 
         def receive_data data # :nodoc:
 
-          @buffer ||= StringIO.new()
-          @buffer.seek(0, IO::SEEK_END)
-          @buffer << data
-          @buffer.rewind
-          logger.debug { "Received #{data.length} bytes: buffer length = #{@buffer.length} pos = #{@buffer.pos}" }
-          loop do
-            if @buffer.length - @buffer.pos > MIN_PACKET 
-                packet_size = @buffer.read(4).unpack("N").first
-                if (@buffer.length - @buffer.pos >= packet_size)
-                    expected_pos = @buffer.pos + packet_size
-                    # We just pass the buffer around and expect packet_size to be consumed
-                    receive_records(@buffer)
-                    if (@buffer.pos != expected_pos)
-                        #this can happen during disconnection with left over packets
-                        #the connection is dying anyway
-                        leftover = @buffer.read(packet_size).unpack("H*")[0]
-                        raise ProtocolError, "Records not consumed #{leftover}"
+            @buffer ||= StringIO.new().set_encoding('binary')
+            @buffer.seek(0, IO::SEEK_END)
+            @buffer << data
+            @buffer.rewind
+            logger.debug { "Received #{data.length} bytes: buffer length = #{@buffer.length} pos = #{@buffer.pos}" }
+            loop do
+                if @buffer.length - @buffer.pos > MIN_PACKET 
+                    packet_size = @buffer.read(4).unpack("N").first
+                    if (@buffer.length - @buffer.pos >= packet_size)
+                        expected_pos = @buffer.pos + packet_size
+                        # We just pass the buffer around and expect packet_size to be consumed
+                        receive_records(@buffer)
+                        if (@buffer.pos != expected_pos)
+                            #this can happen during disconnection with left over packets
+                            #the connection is dying anyway
+                            leftover = @buffer.read(packet_size).unpack("H*")[0]
+                            raise ProtocolError, "Records not consumed #{leftover}"
+                        end
+                        logger.debug { "Consumed packet #{packet_size}. Buffer pos=#{@buffer.pos}, length=#{@buffer.length}" }
+                        next
+                    else
+                        # found the last partial packet
+                        @buffer.seek(-4, IO::SEEK_CUR)
+                        logger.debug { "Buffer contains #{@buffer.length} of #{packet_size} packet" }
                     end
-                    logger.debug { "Consumed packet #{packet_size}. Buffer pos=#{@buffer.pos}, length=#{@buffer.length}" }
-                    next
-                else
-                    # found the last partial packet
-                    @buffer.seek(-4, IO::SEEK_CUR)
-                    logger.debug { "Buffer contains #{@buffer.length} of #{packet_size} packet" }
                 end
+                break
             end
-            break
-          end
-          # reset the buffer
-          @buffer = StringIO.new(@buffer.read()) if @buffer.pos > 0
+            # reset the buffer
+            @buffer = StringIO.new(@buffer.read()) if @buffer.pos > 0
         end
 
         def receive_records(packet_io)
@@ -59,7 +59,7 @@ module ZooKeeper
             bindata.each { |b| send_data(b) }
             logger.debug { "Sent #{length} byte packet containing  #{records.length} records" }
         end
-     end
+    end
 
     class Operation
         attr_reader :op, :opcode, :request, :response, :callback
@@ -68,7 +68,7 @@ module ZooKeeper
             @request=request;@response=response
             @callback=callback
         end
-        
+
         def path
             #Every request has a path!
             #TODO - path may be chrooted!
@@ -78,14 +78,14 @@ module ZooKeeper
 
     class Packet < Operation
         attr_reader :xid, :watch_type, :watcher
-       
+
         def initialize(xid,op,opcode,request,response,watch_type,watcher,callback)
             super(op,opcode,request,response,callback)
             @xid=xid;
             @watch_type = watch_type; @watcher = watcher
         end
 
-        
+
         def error(reason)
             result(reason)[0..2] # don't need the watch
         end
@@ -94,7 +94,7 @@ module ZooKeeper
             error = nil
             unless (Error::NONE === rc) then 
                 error = Error.lookup(rc) 
-                error = error.exception("ZooKeeper error for #{@op}(#{path}) ")
+                error = error.exception("ZooKeeper error #{error.to_sym} for #{@op}(#{path}) ")
             end
             [ callback, error ,response, watch_type ] 
         end
@@ -114,69 +114,5 @@ module ZooKeeper
             Error::SESSION_EXPIRED == rc ? [ callback, nil, nil, nil ] : super(rc)
         end
     end
-
-    
-    # Returned by asynchronous calls
-    # 
-    # @example
-    #    op = zk.stat("\apath") { |stat| something_with_stat() }
-    #
-    #    op.on_error do |err|
-    #      case err
-    #      when ZK::Error::SESSION_EXPIRED 
-    #           puts "Ignoring session expired"
-    #      else
-    #           raise err
-    #      end
-    #    end
-    #
-    #    begin
-    #       result_of_somthing_with_stat = op.value
-    #    rescue StandardError => ex
-    #       puts "Oops, my error handler raised an exception"
-    #    end
-    #
-    #
-    class AsyncOp
-
-        attr_accessor :backtrace
-
-        # Provide an error callback. 
-        # @param block the error callback as a block
-        # @yieldparam [StandardError] the error raised by the zookeeper operation OR by its callback
-        def errback(&block)
-            set_error_handler(block)
-        end
-
-        # @param block the error callback as a Proc
-        def errback=(block)
-            set_error_handler(block)
-        end
-
-        alias :on_error :errback
-
-        # Wait for the async op to finish and returns its value
-        # will raise an exception if 
-        #    the operation itself fails and there is no error handler
-        #    the callback raises a StandardError and there is no error handler
-        #    the error handler raises StandardError
-        def value();
-            wait_value()
-            rescue ZooKeeper::Error => ex
-               # Set the backtrace to the original caller, rather than the ZK event loop
-               ex.set_backtrace(@backtrace) if @backtrace
-               raise ex
-        end
-
-        private
-
-        def set_error_handler(blk)
-            raise NotImplementedError, ":wait_result to be privately implemented by binding"
-        end
-
-        def wait_value();
-            raise NotImplementedError, ":wait_result to be privately implemented by binding"
-        end
-    end
 end