zkruby 3.4.3

data/lib/zkruby/enum.rb

@@ -0,0 +1,108 @@
+
+# Including in a class and us the "enum" DSL method to create class instances
+# As a special case, if the including class is descendant from StandardError, the enumerated
+# instances will be classes descendent from the including class (eg like Errno)
+module Enumeration
+
+    def self.included(base)
+        base.extend(ClassMethods)
+        #  In the normal case we just include our methods in the base class
+        #  but for Errors we need to include them on each instance
+        base.send :include,InstanceMethods unless base < StandardError
+    end
+
+    module InstanceMethods
+        def === (other)
+            case other
+            when Symbol
+                to_sym == other
+            when Fixnum
+                to_int == other
+            else
+                super
+            end
+        end
+
+        def to_i
+            to_int
+        end
+
+        def to_int
+            @index
+        end
+
+        def |(num)
+            to_int | num
+        end
+
+        def &(num)
+            to_int & num
+        end
+
+        def to_sym
+            @name
+        end
+
+        def to_s
+            "#{super} (:#{@name} [#{@index}])"
+        end
+    end
+
+    module ClassMethods
+      
+        # @param [] ref Symbol, Fixnum or Enumeration
+        # @return [Enumeration] instance representing ref or nil if not found
+        def get(ref)
+            @enums[ref]
+        end
+
+        # @param [] ref Symbol, Fixnum 
+        # @raise [KeyError] if ref not found
+        # @return [Enumeration] 
+        def fetch(ref)
+            @enums.fetch(ref)
+        end
+
+        # Will dynamically create a new enum instance if ref is not found
+        def lookup(ref)
+            case ref
+            when Enumeration,Class 
+                ref
+            when Symbol
+                get(ref) || enum(ref,nil)
+            when Fixnum
+                get(ref) || enum(nil,ref)
+            else
+                nil
+            end
+        end
+
+        def enum(name,index,*args)
+            @enums ||= {}
+            
+            instance = if (self < StandardError) then Class.new(self) else self.new(*args) end
+            
+            instance.extend(InstanceMethods) if (self < StandardError)
+
+            const_name = if name.nil?
+                             "ENUM" + index.to_s.sub("-","_")
+                         else
+                             name.to_s.upcase
+                         end
+                            
+            self.const_set(const_name.to_s.upcase,instance)
+            
+            @enums[instance] = instance
+            @enums[name] = instance if name
+            @enums[index] = instance if index
+            instance.instance_variable_set(:@name,name)
+            instance.instance_variable_set(:@index,index)
+            instance.freeze
+        end
+
+        def method_missing(method,*args)
+            @enums[method.downcase] || super
+        end
+
+    end
+end

data/lib/zkruby/eventmachine.rb

@@ -0,0 +1,186 @@
+require 'eventmachine'
+
+if defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /1\.6\.5.*/
+    raise "Fibers are broken in JRuby 1.6.5 (See JRUBY-6170)"
+end
+
+require 'strand'
+
+module ZooKeeper
+    module EventMachine
+
+        class ClientConn < ::EM::Connection
+            include Protocol
+            include Slf4r::Logger        
+
+            unless EventMachine.methods.include?(:set_pending_connect_timeout)
+                def set_pending_connect_timeout(timeout)
+
+                end
+            end  
+
+            def initialize(session,connect_timeout)
+                @session = session
+                @connect_timeout = connect_timeout
+                set_pending_connect_timeout(connect_timeout)
+            rescue Exception => ex
+                logger.warn("Exception in initialize",ex)
+            end
+
+            def post_init()
+            rescue Exception => ex
+                logger.warn("Exception in post_init",ex)
+            end
+
+            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()
+                            end
+                            @ping += 1
+                        end
+                    else
+                        close_connection()
+                    end
+                end
+
+            rescue Exception => ex
+                logger.warn("Exception in connection_completed",ex)
+            end
+
+            def receive_records(packet_io)
+                @ping = 0
+                @session.receive_records(packet_io)
+            end
+
+            def disconnect()
+                close_connection()
+            end
+
+            def unbind
+                EM.cancel_timer(@timer) if @timer
+                @session.disconnected()
+            rescue Exception => ex
+                logger.warn("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?
+            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/multi.rb

@@ -0,0 +1,47 @@
+module ZooKeeper
+
+    module Proto
+
+        #MultiTransactionRecord and MultiResponse in java
+        #are not able to be compiled from Jute because jute doesn't support
+        #discriminators
+        class MultiRequest < BinData::Record
+            array :requests, :read_until => lambda { element.header._type < 0 } do
+                multi_header :header
+                choice :request, :selection => lambda { header._type },
+                    :onlyif => lambda { header._type > 0 } do
+                    create_request 1
+                    delete_request 2
+                    set_data_request 5
+                    check_version_request 13
+                    end
+            end
+
+        end
+
+        class MultiResponseItem < BinData::Record
+            multi_header :header
+            choice :response, :selection => lambda { header._type },
+                :onlyif => lambda { has_response? } do
+                error_response -1
+                create_response 1
+                set_data_response 5
+                end
+
+            def has_response?
+                !done? && [ -1, 1, 5 ] .include?(header._type)
+            end
+
+            def done?
+                # Boolean's don't actually work properly in bindata
+                header.done == true
+            end
+
+        end
+
+        class MultiResponse < BinData::Record
+            array :responses, :type => :multi_response_item, :read_until => lambda { element.done? }
+        end
+    end
+end
+

data/lib/zkruby/protocol.rb

@@ -0,0 +1,182 @@
+require 'stringio'
+
+module ZooKeeper
+    # Represents a problem communicating with the ZK cluster
+    # 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
+        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}"
+                    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
+            end
+            break
+          end
+          # reset the buffer
+          @buffer = StringIO.new(@buffer.read()) if @buffer.pos > 0
+        end
+
+        def receive_records(packet_io)
+            #stub
+            #we don't unpack records here because we don't know what kind of records they are!
+        end
+
+        def send_records(*records)
+            length = 0
+            bindata = records.collect { |r| s = r.to_binary_s; length += s.length; s }
+            send_data([length].pack("N"))
+            bindata.each { |b| send_data(b) }
+            logger.debug { "Sent #{length} byte packet containing  #{records.length} records" }
+        end
+     end
+
+    class Operation
+        attr_reader :op, :opcode, :request, :response, :callback
+        def initialize(op,opcode,request,response,callback)
+            @op=op;@opcode=opcode
+            @request=request;@response=response
+            @callback=callback
+        end
+        
+        def path
+            #Every request has a path!
+            #TODO - path may be chrooted!
+            request.path if request.respond_to?(:path)
+        end
+    end
+
+    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
+
+        def result(rc)
+            error = nil
+            unless (Error::NONE === rc) then 
+                error = Error.lookup(rc) 
+                error = error.exception("ZooKeeper error for #{@op}(#{path}) ")
+            end
+            [ callback, error ,response, watch_type ] 
+        end
+    end
+
+    # NoNode error is expected for exists
+    class ExistsPacket < Packet
+        def result(rc)
+            Error::NO_NODE === rc ? [ callback, nil, nil, :exists ] : super(rc)
+        end
+    end
+
+    # In the normal case the close packet will be last and will get
+    # cleared via disconnected() and :session_expired
+    class ClosePacket < Packet
+        def result(rc)
+            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
+