zkruby 3.4.4.rc3 → 3.4.4.rc4

data/lib/em_zkruby.rb

@@ -1,4 +1,6 @@
 # This is the main require for the eventmachine based binding
-
+# Only use this if all use of zkruby will be within the EM Reactor 
 require 'zkruby/zkruby'
 require 'zkruby/eventmachine'
+
+Empathy::EM.empathise(ZooKeeper)

data/lib/zkruby/async_op.rb

@@ -30,7 +30,7 @@ module ZooKeeper
             @event_loop = event_loop
             @operation = operation
             @callback = callback
-            @mutex,@cv = Strand::Mutex.new(), Strand::ConditionVariable.new()
+            @mutex,@cv = Mutex.new(), ConditionVariable.new()
             begin
                 execute()
             rescue ZooKeeper::Error => ex
@@ -181,7 +181,8 @@ module ZooKeeper
                     event_loop.pop_event_queue()
                 end
             else
-                mutex.synchronize { 
+                mutex.synchronize {
+                    logger.debug("Async op is waiting")
                     cv.wait(mutex) unless resumed?
                 }
             end

data/lib/zkruby/client.rb

@@ -117,26 +117,14 @@ module ZooKeeper
     # @return [Client] 
     def self.connect(addresses,options={},&block)
 
-        binding_module = if Strand.event_machine?                 
-            require 'zkruby/eventmachine'
-            ZooKeeper::EventMachine::Binding
-        else
-            require 'zkruby/rubyio'
-            ZooKeeper::RubyIO::Binding
-        end
-
-        logger.debug { "Using binding #{binding_module}" }
         session = Session.new(addresses,options)
-        # Extend the appropriate #connect method into the session
-        session.extend(binding_module)
-
         client = Client.new(session)
 
         session.start(client)
         
         return client unless block_given?
 
-        storage = Strand.current[CURRENT] ||= []
+        storage = Thread.current[CURRENT] ||= []
         storage.push(client)
         begin
             yield client
@@ -151,13 +139,12 @@ module ZooKeeper
     # current ZK client
     def self.current
         #We'd use if key? here if strand supported it
-        Strand.current[CURRENT].last if Strand.current[CURRENT]
+        Thread.current[CURRENT].last if Thread.current.key?(CURRENT)
     end
 
     # Allow ZK a chance to send its data/ping
-    # particularly required for the eventmachine binding
     def self.pass
-        Strand.pass
+        Thread.pass
     end
 
     class WatchEvent

data/lib/zkruby/conn.rb

@@ -0,0 +1,108 @@
+require 'zkruby/socket'
+module ZooKeeper
+
+    class Connection
+        include ZooKeeper::Protocol
+        include Slf4r::Logger
+
+        attr_reader :session
+
+        def initialize(session)
+            @session = session
+        end
+
+        def run(host,port,timeout)
+            @write_queue = Queue.new()
+
+            begin
+                sock = Socket.tcp_connect_timeout(host,port,timeout)
+                sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+                sock.sync=true
+                write_thread = Thread.new(sock) { |sock| write_loop(sock) } 
+                begin
+                    session.prime_connection(self)
+                    read_loop(sock)
+                ensure
+                    disconnect(sock)
+                end
+                write_thread.join
+            rescue Errno::ECONNREFUSED
+                logger.warn{"Connection refused to #{host}:#{port}"}
+            end
+        end
+
+        # This is called from random client threads (including the event loop)
+        def send_data(data)
+            @write_queue.push(data) if data
+        end
+
+        private
+
+        # Since this runs in its very own thread and has no timers
+        # we can use boring blocking IO
+        def write_loop(socket)
+            Thread.current[:name] = "ZK::WriteLoop #{self} #{socket} #{session}"
+            begin
+                while !socket.closed? && data = @write_queue.pop()
+                    socket.write(data) 
+                    logger.debug { "Sent: #{data.unpack("H*")[0]}" }
+                end
+                logger.debug { "Write loop finished" }
+            rescue Exception => ex
+                logger.warn( "Exception in write loop",ex )
+                # Make sure we break out of the read loop
+                disconnect(socket)
+            end
+        end
+
+        def read_loop(socket)
+            ping = 0
+            until socket.closed?
+                begin
+                    data = socket.read_timeout(512,session.ping_interval)
+                    if data.nil?
+                        logger.debug { "Read timed out" }
+                        ping += 1
+                        case ping
+                        when 1 ; session.ping()
+                        when 2 
+                            logger.warn{"No response to ping in #{session.ping_interval}*2"}
+                            break
+                        end
+                    else
+                        logger.debug { "Received (#{data.length})" + data.unpack("H*")[0] }
+                        receive_data(data)
+                        ping = 0
+                    end
+                rescue EOFError
+                    # This is how we expect to end - send a close packet and the
+                    # server closes the socket
+                    logger.debug { "EOF reading from socket" }
+                    break
+                end
+            end
+        end
+
+        # @api protocol
+        def receive_records(packet_io)
+            session.receive_records(packet_io)
+        end
+
+        def disconnect(socket)
+            @write_queue.push(nil)
+            socket.close if socket and !socket.closed?
+        rescue Exception => ex
+            #oh well
+            logger.debug("Exception closing socket",ex)
+        end
+    end
+end
+
+module ZooKeeperBinding
+
+    # connect and read from the socket until disconnected
+    def self.connect(session,host,port,timeout)
+        ZooKeeper::Connection.new(session).run(host,port,timeout)
+    end
+end
+

data/lib/zkruby/enum.rb

@@ -32,11 +32,11 @@ module Enumeration
         end
 
         def |(num)
-            to_int | num
+            @index | num
         end
 
         def &(num)
-            to_int & num
+            @index & num
         end
 
         def to_sym
@@ -46,6 +46,10 @@ module Enumeration
         def to_s
             "#{super} (:#{@name} [#{@index}])"
         end
+
+        def coerce(other)
+            [self,other]
+        end
     end
 
     module ClassMethods

data/lib/zkruby/eventmachine.rb

@@ -1,16 +1,14 @@
 require 'eventmachine'
+require 'empathy'
 
 if defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /1\.6\.5.*/
     raise "Fibers are broken in JRuby 1.6.5 (See JRUBY-6170)"
 end
 
-# Tell Strand that we want to consider event machine
-Strand.reload()
-
 module ZooKeeper
     module EventMachine
 
-        class ClientConn < ::EM::Connection
+        class Connection < ::EM::Connection
             include Protocol
             include Slf4r::Logger        
 
@@ -31,34 +29,37 @@ module ZooKeeper
             end
 
             # This "loop" is a means of keeping all the session activity
-            # on the session strand
+            # on the session fiber
             def read_loop()
                 event,*args = Fiber.yield
                 if (event == :connection_completed)
                     logger.debug("Connection completed")
                     session.prime_connection(self)
 
-                    @timer = EM.add_timer(@connect_timeout) do
-                        @fiber.resume(:connect_timer)
+                    @timer = ::EventMachine.add_timer(session.ping_interval) do
+                        resume(:connect_timer)
                     end
 
                     ping = 0
+                    unbound = false
                     # If session sleeps or waits in here then our yield/resumes are going to get out of sync
-                    while true
+                    until unbound
                         event,*args = Fiber.yield
+                        logger.debug { "Received event #{event} with #{args}" }
                         case event
                         when :connect_timer
                             if session.connected?
-                                @timer = EM.add_periodic_timer(session.ping_interval) do
-                                    @fiber.resume(:ping_timer)
+                                @timer = ::EventMachine.add_periodic_timer(session.ping_interval) do
+                                    resume(:ping_timer) 
                                 end
                             else
-                                close_connection()
+                                logger.warn("Connection timed out")
+                                break;
                             end
                         when :ping_timer
                             case ping
                             when 1 then session.ping
-                            when 2 then close_connection
+                            when 2 then break;
                             end
                             ping += 1
                         when :receive_records
@@ -66,44 +67,55 @@ module ZooKeeper
                             ping = 0
                             session.receive_records(packet_io)
                         when :unbind
-                            break
+                            unbound = true
+                        else
+                            logger.error("Unexpected resume - #{event}")
+                            break;
                         end
                     end
                 end
-                EM.cancel_timer(@timer) if @timer
-                session.disconnected
+            ensure
+                @fiber = nil
+                ::EventMachine.cancel_timer(@timer) if @timer
+                close_connection() unless unbound
             end
 
             def connection_completed()
-                @fiber.resume(:connection_completed)
-            rescue Exception => ex
-                logger.error("Exception in connection_completed",ex)
+                resume(:connection_completed)
             end
 
             def receive_records(packet_io)
-                @fiber.resume(:receive_records,packet_io)
-            rescue Exception => ex
-                logger.error("Exception in receive_records",ex)
+                resume(:receive_records,packet_io)
             end
 
-            def disconnect()
-                close_connection()
+            def unbind(reason)
+                logger.warn{"Connection #{self} unbound due to #{reason}"} if reason
+                resume(:unbind)
             end
 
-            def unbind
-                @fiber.resume(:unbind)
+            private
+            def resume(event,*args)
+                @fiber.resume(event,*args) if @fiber
             rescue Exception => ex
-                logger.error("Exception in unbind",ex)
+                logger.error("Exception resuming #{@fiber} for event #{event}",ex)
             end
-
         end
+    end #module EventMachine
+
+end #module ZooKeeper
+
+module Empathy
 
-        module Binding
-            def connect(host,port,timeout)
-                conn = EM.connect(host,port,ZooKeeper::EventMachine::ClientConn,self,timeout)
+    module EM
+        module ZooKeeperBinding
+            def self.connect(session,host,port,timeout)
+                conn = ::EventMachine.connect(host,port,ZooKeeper::EventMachine::Connection,session,timeout)
                 conn.read_loop
             end
         end #class Binding
+    end #module EM
+
+    create_delegate_module('ZooKeeperBinding',:connect)
+
+end #module Empathy
 
-    end #module EventMachine
-end #module ZooKeeper

data/lib/zkruby/protocol.rb

@@ -71,7 +71,6 @@ module ZooKeeper
 
         def path
             #Every request has a path!
-            #TODO - path may be chrooted!
             request.path if request.respond_to?(:path)
         end
     end

data/lib/zkruby/session.rb

@@ -1,7 +1,6 @@
 require 'set'
-require 'strand'
-require 'strand/monitor'
-#TODO Move async_op into this file
+require 'thread'
+require 'monitor'
 require 'zkruby/async_op'
 module ZooKeeper
 
@@ -9,8 +8,6 @@ module ZooKeeper
     #
     # @note this is a private API not intended for client use
     class Session
-        # TODO this class is too big
-
         # There are multiple threads of execution involved in a session
         # Client threads - send requests
         # Connection/Read thread
@@ -23,7 +20,7 @@ module ZooKeeper
         # conjunction with processing all entries in @pending_queue
         #
         # All interaction with the event loop occurs via a Queue
-        include Strand::MonitorMixin
+        include MonitorMixin
 
         DEFAULT_TIMEOUT = 4
         DEFAULT_CONNECT_DELAY = 0.2
@@ -115,8 +112,7 @@ module ZooKeeper
             end
         end
 
-        # @api connection
-        # called when the connection has dropped from either end
+        # TODO: Merge all this into a connect loop called from start
         def disconnected()
             logger.info { "Disconnected id=#{@session_id}, keeper=:#{@session_state}, client=:#{@client_state}" }
 
@@ -145,20 +141,18 @@ module ZooKeeper
             raise ProtocolError, "Already started!" unless @session_state.nil?
             @session_state = :disconnected
             @disconnect_time = Time.now
-            logger.debug("Starting new zookeeper client session")
+            logger.debug {"Starting new zookeeper client session for #{client}"}
             @event_loop = EventLoop.new(client)
-            Strand.new { 
-                begin
+            # This is the read/connect thread
+            Thread.new {
+                Thread.current[:name] = "ZK::Session #{self}"
+                reconnect()
+                while active?
+                    delay = rand() * @max_connect_delay
+                    sleep(delay)
                     reconnect()
-                    while active? 
-                        delay = rand() * @max_connect_delay
-                        Strand.sleep(delay)
-                        reconnect()
-                    end
-                rescue Exception => ex
-                    logger.error("Exception in connect loop",ex)
                 end
-            logger.debug("Session complete")
+                logger.debug {"Session #{self} complete" }
             }
         end
 
@@ -198,6 +192,11 @@ module ZooKeeper
             [:connected,:disconnected].include?(@session_state)
         end
 
+        def calculate_timeouts()
+            @ping_interval = timeout * 2.0/7.0
+            @connect_timeout = timeout / 2.0
+        end
+
         def queue_request(request,op,opcode,response=nil,watch_type=nil,watcher=nil,ptype=Packet,&callback)
             synchronize do 
                 raise ProtocolError, "Client closed #{@client_state}" unless @client_state == :ready
@@ -262,8 +261,8 @@ module ZooKeeper
 
         def parse_options(options)
             @timeout = options.fetch(:timeout,DEFAULT_TIMEOUT)
+            calculate_timeouts()
             @max_connect_delay = options.fetch(:connect_delay,DEFAULT_CONNECT_DELAY)
-            @connect_timeout = options.fetch(:connect_timeout,@timeout * 1.0 / 7.0)
             @scheme = options.fetch(:scheme,nil)
             @auth = options.fetch(:auth,nil)
             @chroot = options.fetch(:chroot,"").chomp("/")
@@ -273,8 +272,14 @@ module ZooKeeper
             #Rotate address
             host,port = @addresses.shift
             @addresses.push([host,port])
-            logger.debug { "Connecting id=#{@session_id} to #{host}:#{port} with timeout=#{@connect_timeout}" } 
-            connect(host,port,@connect_timeout)
+            logger.debug { "Connecting id=#{@session_id} to #{host}:#{port} with timeout=#{@connect_timeout} #{ZooKeeperBinding.inspect}" } 
+            begin
+                ZooKeeperBinding.connect(self,host,port,@connect_timeout)
+            rescue Exception => ex
+                logger.warn("Exception in connect loop", ex)
+            ensure
+                disconnected()
+            end
         end
 
         def session_expired(reason=:expired)
@@ -297,9 +302,10 @@ module ZooKeeper
                 session_expired() 
             else
                 @timeout = result.time_out.to_f / 1000.0
+                calculate_timeouts()
                 @session_id = result.session_id
                 @session_passwd = result.passwd
-                logger.info { "Connected session_id=#{@session_id}, timeout=#{@time_out}, ping=#{@ping_interval}" }
+                logger.info { "Connected session_id=#{@session_id}, timeout=#{@timeout}, ping=#{@ping_interval}" }
 
                 # Why 2 / 7 of the timeout?. If a binding sees no server response in this period it is required to
                 # generate a ping request
@@ -386,13 +392,11 @@ module ZooKeeper
 
                 if (packet.xid.to_i != header.xid.to_i)
 
-                    logger.error { "Bad XID! expected=#{packet.xid}, received=#{header.xid}" }
-
                     # Treat this like a dropped connection, and then force the connection
                     # to be dropped. But wait for the connection to notify us before
                     # we actually update our keeper_state
                     invoke_response(*packet.error(:disconnected))
-                    @conn.disconnect() 
+                    raise ProtocolError, "Bad XID. expected=#{packet.xid}, received=#{header.xid}"
                 else
                     @last_zxid_seen = header.zxid
 
@@ -435,7 +439,7 @@ module ZooKeeper
             elsif watch.respond_to?(:call)
                 callback = watch
             else
-                raise ProtocolError("Bad watcher #{watch}")
+                logger.error("Bad watcher #{watch}")
             end
             @event_loop.invoke(callback,state,unchroot(path),event)
         end
@@ -458,7 +462,7 @@ module ZooKeeper
             # client requests are rejected
             # we can receive watch and ping notifications after this
             # but the server drops the connection as soon as this
-            # packet arrives
+            # packet is received
             if @pending_queue.empty? && @session_state == :connected && @close_packet
                 logger.debug { "Sending close packet!" }
                 send_packet(@close_packet)
@@ -519,16 +523,16 @@ module ZooKeeper
             include Slf4r::Logger
 
             def initialize(client)
-                @event_queue = Strand::Queue.new()
+                @event_queue = Queue.new()
 
                 @alive = true
-                @event_thread  = Strand.new() do
+                @event_thread  = Thread.new() do
                     logger.debug { "Starting event loop" }
-                    Strand.current[:name] = "ZooKeeper::EventLoop"
-                    Strand.current[CURRENT] = [ client ]
+                    Thread.current[:name] = "ZK::EventLoop #{self}"
+                    Thread.current[CURRENT] = [ client ]
                     begin
                         pop_event_queue until dead?
-                        logger.debug { "Finished event loop" }
+                        logger.info { "Finished event loop" }
                     rescue Exception => ex
                         logger.error("Uncaught exception in event loop",ex)
                     end
@@ -542,7 +546,8 @@ module ZooKeeper
             # @api async_op
             def pop_event_queue
                 #We're alive until we get a nil result from #stop
-                queued = @event_queue.pop if @alive
+                logger.debug { "Popping event queue" }
+                queued = @alive ? @event_queue.pop : nil
                 if queued 
                     begin
                         callback,*args = queued
@@ -561,7 +566,7 @@ module ZooKeeper
             end
 
             def invoke_close(callback,*args)
-                Strand.new do
+                Thread.new do
                     @event_thread.join()
                     callback.call(*args)
                 end
@@ -570,11 +575,12 @@ module ZooKeeper
             # @api session
             def stop
                 @event_queue.push(nil)
+                @event_thread.join()
             end
 
             # @api async_op
             def current?
-                Strand.current == @event_thread
+                Thread.current == @event_thread
             end
         end
     end # Session

data/lib/zkruby/socket.rb

@@ -0,0 +1,66 @@
+require  'socket'
+
+class Socket
+
+    HAS_NONBLOCKING_CONNECT =  RUBY_PLATFORM != "java"|| Gem::Version.new(JRUBY_VERSION.dup) >= Gem::Version.new("1.6.7")
+
+    def self.tcp_connect_timeout(host,port,timeout = 0)
+
+        if HAS_NONBLOCKING_CONNECT && timeout > 0
+            # TODO: This is a blocking DNS lookup!!!!, possibly even a reverse lookup if host is a numberic address
+            addr = self.getaddrinfo(host, nil)
+            sock = Socket.new(self.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+            sockaddr = Socket.pack_sockaddr_in(port, addr[0][3])
+
+            begin
+                sock.connect_nonblock(sockaddr)
+                return sock
+            rescue Errno::EINPROGRESS
+                begin
+                    #Note: JRuby raises Connection Refused instead of populating error array
+                    read,write,errors  = Socket.select(nil, [sock], [sock], timeout)
+                    optval = sock.getsockopt(Socket::SOL_SOCKET,Socket::SO_ERROR)
+                    sockerr = (optval.unpack "i")[0]
+                end
+
+                case sockerr
+                when 0 # Errno::NOERROR::Errno
+                    begin
+                        sock.connect_nonblock(sockaddr)
+                        return sock
+                    rescue Errno::EISCONN
+                        #Woohoo! we're connected
+                        return sock
+                    end
+                when Errno::EINPROGRESS
+                    # must be a timeout
+                    logger.warn{"Connect timeout to #{host}:#{port}"}
+                    return nil
+                when Errno::ECONNREFUSED::Errno
+                    raise Errno::ECONNREFUSED, "Connection refused to #{ host }:#{ port }"
+                else
+                    raise Errno::ENOTCONN, "Connection to #{ host }:#{ port } failed: #{sockerr}"
+                end
+            end
+        else
+            # JRuby prior to 1.6.7 cannot do non-blocking connects, which means there is
+            # no way to properly implement the connection-timeout
+            # See http://jira.codehaus.org/browse/JRUBY-5165 
+            # In any case this should be encapsulated in TCPSocket.open(host,port,timeout)
+            self.tcp(host,port) 
+        end
+
+    end
+
+    def read_timeout(maxlen,timeout)
+        begin
+           return read_nonblock(maxlen)
+        rescue IO::WaitReadable
+            selected = IO.select([self],[],[],timeout)
+            return nil unless selected
+            retry
+        end
+    end
+end
+
+

data/lib/zkruby/version.rb

@@ -1,5 +1,5 @@
 
 module ZooKeeper
     # Major/Minor numbers track zookeeper itself, final digit is our build number
-    VERSION = "3.4.4.rc3"
+    VERSION = "3.4.4.rc4"
 end

data/lib/zkruby/zkruby.rb

@@ -15,6 +15,7 @@ require 'zkruby/bindata'
 require 'jute/zookeeper'
 require 'zkruby/multi'
 require 'zkruby/protocol'
+require 'zkruby/conn'
 require 'zkruby/session'
 require 'zkruby/client'
 # Utilities

data/lib/zkruby.rb

@@ -1,4 +1,3 @@
 # This is the main require for standard ruby io/thread based binding
 
 require 'zkruby/zkruby'
-require 'zkruby/rubyio'

data/spec/enum_spec.rb

@@ -24,6 +24,8 @@ describe Enumeration do
         t.should === 1
     end
 
+    it "should do coercion"
+
     it "should be useable in a mock" do
         m = mock("watchevent")
         m.should_receive(:test).with(TestEnum::TWO)

data/spec/eventmachine_spec.rb

@@ -1,29 +1,21 @@
 require 'server_helper'
-require 'shared/binding'
 require 'zkruby/eventmachine'
+require 'shared/binding'
 
-describe ZooKeeper::EventMachine::Binding do
+Empathy.empathise(ZooKeeper)
+
+describe Empathy::EM::ZooKeeperBinding do
 
     include Slf4r::Logger
 
     around(:each) do |example|
-        EventMachine.run {
-            Strand.new() do
-            begin
-                example.run
-            rescue Exception => ex
-                logger.error("Exception in example",ex)
-            ensure
-                EM::stop
-            end
-            end
-        }
+        Empathy.run { example.run }
     end
 
     it "should be running in event machine" do
-        Strand.event_machine?.should be_true
+        Empathy.event_machine?.should be_true
     end
 
+    let (:pass_every) { 3 }
     it_should_behave_like "a zookeeper client binding"
-
 end

data/spec/rubyio_spec.rb

@@ -1,8 +1,8 @@
 require 'server_helper'
 require 'shared/binding'
-require 'zkruby/rubyio'
 
-describe ZooKeeper::RubyIO::Binding do
+describe ZooKeeperBinding do
+    let (:pass_every) { nil }
     it_behaves_like "a zookeeper client binding"
 end
 

data/spec/server_helper.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ZooKeeperServerHelper
+module ZooKeeperServerManager
 
     include Slf4r::Logger
 
@@ -9,17 +9,17 @@ module ZooKeeperServerHelper
     def jruby_safe_system(arg)
         arg = "#{arg} &" if JRUBY_COMPAT_SYSTEM
         system(arg)
-        Strand.sleep(3) if JRUBY_COMPAT_SYSTEM
+        sleep(3) if JRUBY_COMPAT_SYSTEM
     end
 
     def restart_cluster(delay=0)
         jruby_safe_system("../../bin/zkServer.sh stop >> zk.out")
-        Strand::sleep(delay) if delay > 0
+        sleep(delay) if delay > 0
         jruby_safe_system("../../bin/zkServer.sh start >> zk.out")
     end
 
     def get_addresses()
-        "localhost:2181"
+        "127.0.0.1:2181"
     end
 
     def safe_close(zk)
@@ -34,10 +34,10 @@ module ZooKeeperServerHelper
 
 end
 
-include ZooKeeperServerHelper
+include ZooKeeperServerManager
 
 restart_cluster()
-Strand.sleep(3)
+sleep(3)
 require 'net/telnet'
 t = Net::Telnet.new("Host" => "localhost", "Port" => 2181)
 properties = t.cmd("mntr")
@@ -45,5 +45,5 @@ properties = t.cmd("mntr")
 RSpec.configure do |c|
     #Exclude multi unless we are on a 3.4 server
     c.filter_run_excluding :multi => true unless properties
-    c.filter_run_excluding :perf => true
+    #c.filter_run_excluding :perf => true
 end

data/spec/shared/basic.rb

@@ -4,8 +4,10 @@ shared_examples_for "basic integration" do
          @zk.create("/zkruby","node for zk ruby testing",ZK::ACL_OPEN_UNSAFE) unless @zk.exists?("/zkruby")
     end
 
+    context("normal functions") do
     it "should return a stat for the root path" do
-        stat = @zk.stat("/")
+
+        stat = @zk.stat("/") 
         stat.should be_a ZooKeeper::Data::Stat
     end
 
@@ -40,7 +42,7 @@ shared_examples_for "basic integration" do
         @zk.delete("/zkruby/rspec",-1)
         @zk.exists?("/zkruby/rspec").should be_false
     end
-
+    end
     context "exceptions" do
 
         it "should raise ZK::Error for synchronous method" do
@@ -147,7 +149,7 @@ shared_examples_for "basic integration" do
     context "auto reconnect" do
 
         it "should stay connected" do
-            Strand.sleep(@zk.timeout * 2.0)
+            sleep(@zk.timeout * 2.0)
             @zk.exists?("/zkruby").should be_true
         end
 

data/spec/shared/performance.rb

@@ -11,17 +11,13 @@ shared_examples_for "performance" do
             op = nil
             start = Time.now
             count = 0
-            pass_every = 5
             first_error = true
             6000.times do
                 count += 1
                 this_index = count
                 op = @zk.create("#{path}/","hello", ZK::ACL_OPEN_UNSAFE,:sequential,:ephemeral) { } 
                 op.on_error { |ex| puts "Error @ #{this_index}" if first_error; first_error = false }
-                if count % pass_every == 0
-                    #puts "Passing @ #{count}"
-                    ZK.pass
-                end
+                ZK.pass if pass_every && count % pass_every == 0
             end
 
             op.value
@@ -34,10 +30,7 @@ shared_examples_for "performance" do
             children.each do |child|
                 op = @zk.get("#{path}/#{child}") { }
                 count += 1
-                if count % pass_every == 0
-                    #puts "Passing @ #{count}"
-                    ZK.pass
-                end
+                ZK.pass if pass_every && count % pass_every == 0
             end
 
             op.value

data/spec/shared/watch.rb

@@ -18,7 +18,7 @@ shared_examples_for "watches" do
             stat,data = @zk.get(path,watch)
             # set the data on the 2nd session
             @zk2.set(path,"newdata",stat.version)
-            Strand.sleep(2)
+            sleep(2)
             watch_results.size().should == 1
             watch_results[0][1].should == path
             watch_results[0][2].should === :node_data_changed
@@ -31,7 +31,7 @@ shared_examples_for "watches" do
 
             stat,children = @zk.children("/zkruby",watch)
             path = @zk2.create("/zkruby/rspec_watch","somedata",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
-            Strand.sleep(2)
+            sleep(2)
             watch_results.size().should == 1
             watch_results[0][1].should == "/zkruby"
             watch_results[0][2].should === :node_children_changed

data/spec/spec_helper.rb

@@ -3,10 +3,13 @@ require 'zkruby/zkruby'
 
 Logging.logger.root.level = :warn
 Logging.logger.root.appenders = Logging.appenders.stdout(:layout => Logging.layouts.pattern(:pattern => '%r %c [%T] %-5l: %m\n'))
-#Logging.logger[ZooKeeper::RubyIO::Connection].level = :error
+#Logging.logger[ZooKeeper::Connection].level = :debug
+#Logging.logger['ZooKeeper::EventMachine::Connection'].level = :debug
 #Logging.logger["ZooKeeper::RubyIO::Binding"].level = :debug
 #Logging.logger[ZooKeeper::Session].level = :debug
+#Logging.logger[ZooKeeper::AsyncOp].level = :debug
 #Logging.logger["ZooKeeper::EventMachine::ClientConn"].level = :debug
 #Logging.logger["ZooKeeper::Session::Ping"].level = :error
 
 Thread.current[:name] = "Rspec::Main"
+

data/zkruby.gemspec

@@ -14,23 +14,24 @@ Gem::Specification.new do |s|
   s.description = %q{Supports full ZooKeeper API, synchronous or asynchronous style, watches etc.. with implementations over EventMachine or plain old Ruby IO/Threads}
 
   s.files         = `git ls-files`.split("\n")
-  s.files << 'lib/jute/zookeeper.rb'
+  s.files         << 'lib/jute/zookeeper.rb'
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")
   s.require_paths = ["lib"]
 
-  s.has_rdoc = 'yard'
   # Yard options in .yardopts
 
   s.add_dependency 'slf4r' , '~> 0.4.2'
-  s.add_dependency 'strand', '~> 0.2.0.rc0'
   s.add_dependency 'bindata', '~> 1.4.1'
 
   s.add_development_dependency 'eventmachine', '>= 0.12.10'
+  s.add_development_dependency 'empathy', '>=0.1.0'
   s.add_development_dependency 'logging', '>= 1.4.1'
+  s.add_development_dependency 'ruby-prof'
 
   s.add_development_dependency("rake")
   s.add_development_dependency("rspec")
   s.add_development_dependency("yard")
+  s.add_development_dependency("kramdown")
  
   # s.add_development_dependency("jute") 
   s.add_development_dependency "citrus" , '~> 2.4.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zkruby
 version: !ruby/object:Gem::Version
-  version: 3.4.4.rc3
+  version: 3.4.4.rc4
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-17 00:00:00.000000000 Z
+date: 2013-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slf4r
@@ -28,13 +28,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.4.2
 - !ruby/object:Gem::Dependency
-  name: strand
+  name: bindata
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.0.rc0
+        version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,31 +42,31 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.0.rc0
+        version: 1.4.1
 - !ruby/object:Gem::Dependency
-  name: bindata
+  name: eventmachine
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.1
-  type: :runtime
+        version: 0.12.10
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 0.12.10
 - !ruby/object:Gem::Dependency
-  name: eventmachine
+  name: empathy
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.10
+        version: 0.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -74,7 +74,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.10
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: logging
   requirement: !ruby/object:Gem::Requirement
@@ -91,6 +91,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -139,6 +155,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: citrus
   requirement: !ruby/object:Gem::Requirement
@@ -170,7 +202,6 @@ files:
 - README.rdoc
 - Rakefile
 - jute/jute.citrus
-- jute/lib/hoe/jute.rb
 - jute/lib/jute.rb
 - jute/lib/jute/task.rb
 - lib/em_zkruby.rb
@@ -178,12 +209,13 @@ files:
 - lib/zkruby/async_op.rb
 - lib/zkruby/bindata.rb
 - lib/zkruby/client.rb
+- lib/zkruby/conn.rb
 - lib/zkruby/enum.rb
 - lib/zkruby/eventmachine.rb
 - lib/zkruby/multi.rb
 - lib/zkruby/protocol.rb
-- lib/zkruby/rubyio.rb
 - lib/zkruby/session.rb
+- lib/zkruby/socket.rb
 - lib/zkruby/util.rb
 - lib/zkruby/version.rb
 - lib/zkruby/zkruby.rb
@@ -221,9 +253,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2131471662065326967
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -232,9 +261,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Pure Ruby language binding for ZooKeeper
 test_files: []
-has_rdoc: yard
+has_rdoc: 

data/jute/lib/hoe/jute.rb

@@ -1,56 +0,0 @@
-# coding: utf-8
-
-module Hoe::Jute
-   attr_accessor :jute
-   attr_accessor :jute_tasks
-   attr_accessor :jute_modules
-
-   #attr_accessor :jute_compiler
-   def initialize_jute
-        self.jute_tasks = [:test,:spec,:package]
-        #dependency 'jute' # if jute is ever a separate gem
-        dependency 'citrus', '~> 2.4.0', :development
-        dependency 'bindata', '~> 1.4.1'
-   end
-
-   def define_jute_tasks
-
-      found = try_load_jute()
-
-      if found
-         jute_compiler = ::Jute::Compiler.new()
-         jute_files   = self.spec.files.find_all { |f| f =~ /\.jute$/ }
-
-         record_files = jute_files.map { |f| f.pathmap("%{src,lib}X.rb") }
-         self.clean_globs += record_files
-
-
-          rule ".rb" => ["%{lib,src}X.jute"] do |t|
-              File.open(t.source) do |input|
-                File.open(t.name,"w") do |output|
-                    puts "compiling #{input.inspect} to #{output.inspect}"
-                    jute_compiler.compile(input,output,jute_modules)
-                end
-              end
-          end
-
-          desc "generate jute records" unless jute_files.empty?
-          task :jute
-
-          task :jute => record_files
-
-          jute_tasks.each do |t|
-            task t => [:jute]
-          end
-       end
-   end
-
-   def try_load_jute()
-        require 'jute'
-   rescue LoadError => err
-        warn "%p while trying to load jute: %s" % [ err.class, err.message ]
-        false
-   end
-end
-
-

data/lib/zkruby/rubyio.rb

@@ -1,198 +0,0 @@
-require 'socket'
-require 'thread'
-
-# Binding over standard ruby sockets
-#
-# Manages 3 threads per zookeeper session
-#
-# Read thread
-#   manages connecting to and reading from the tcp socket. Uses non blocking io to manage timeouts
-#   and initiate the required ping requests.
-#
-# Write thread
-#   each new connection spawns a new thread. Requests coming from the session in response
-#   to multiple threads are written to a blocking queue. While the connection is alive
-#   this thread reads from the queue and writes to the socket, all in blocking fashion
-#   TODO: Is it really ok to do a non-blocking read during a blocking write?
-# 
-# Event thread
-#   All response and watch callbacks are put on another blocking queue to be read and executed
-#   by this thread.
-#
-# All interaction with the session is synchronized
-#
-# Client synchronous code is implemented with a condition variable that waits on the callback/errback 
-#
-
-# JRuby does not define Errno::NOERROR
-unless defined? Errno::NOERROR 
-    class Errno::NOERROR < SystemCallError
-        Errno = 0
-    end
-
-end
-
-module ZooKeeper::RubyIO
-
-    class Connection
-        include ZooKeeper::Protocol
-        include Slf4r::Logger
-        include Socket::Constants
-
-        HAS_NONBLOCKING_CONNECT =  RUBY_PLATFORM != "java"|| Gem::Version.new(JRUBY_VERSION.dup) >= Gem::Version.new("1.6.7")
-        SOL_TCP = IPPROTO_TCP unless defined? ::Socket::SOL_TCP
-
-        attr_reader :session
-
-        def initialize(host,port,timeout,session)
-            @session = session
-            @write_queue = Queue.new()
-
-            if HAS_NONBLOCKING_CONNECT
-                addr = Socket.getaddrinfo(host, nil)
-                sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-                sock.setsockopt(SOL_SOCKET, SO_LINGER, [0,-1].pack("ii"))
-                begin
-                    sock.setsockopt(SOL_TCP, TCP_NODELAY,[0].pack("i_"))
-                rescue
-                    # JRuby defines SOL_TCP, but it doesn't work
-                    sock.setsockopt(IPPROTO_TCP, TCP_NODELAY,[0].pack("i_"))
-                end
-
-                sockaddr = Socket.pack_sockaddr_in(port, addr[0][3])
-                begin
-                    sock.connect_nonblock(sockaddr)
-                rescue Errno::EINPROGRESS
-                  
-                    begin
-                        read,write,errors  = IO.select(nil, [sock], nil, timeout)
-                        optval = sock.getsockopt(Socket::SOL_SOCKET,Socket::SO_ERROR)
-                        sockerr = (optval.unpack "i")[0]
-                    rescue Exception => ex
-                        #JRuby raises Connection Refused instead of populating error array
-                        logger.warn( "Exception from non blocking select", ex )
-                        sockerr=-1
-                    end
-
-                    if sockerr == Errno::NOERROR::Errno
-                        begin
-                            sock.connect_nonblock(sockaddr)
-                        rescue Errno::EISCONN
-                            #Woohoo! we're connected
-                        rescue Exception => ex
-                            logger.warn( "Exception after successful connect",ex )
-                            sock = nil
-                        end
-                    else
-                        if sockerr == Errno::ECONNREFUSED::Errno
-                            logger.warn("Connection refused to #{ host }:#{ port }")
-                        else
-                            logger.warn("Connection to #{ host }:#{ port } failed: #{sockerr}")
-                        end
-                        sock = nil
-                    end
-                end
-            else
-            # JRuby prior to 1.6.7 cannot do non-blocking connects, which means there is
-            # no way to properly implement the connection-timeout
-            # See http://jira.codehaus.org/browse/JRUBY-5165 
-            # In any case this should be encapsulated in TCPSocket.open(host,port,timeout)
-                logger.warn { "Using blocking connect (JRuby < 1.6.7)" }
-                begin
-                    sock = TCPSocket.new(host,port.to_i)
-                rescue Errno::ECONNREFUSED
-                    logger.warn("TCP Connection refused to #{host}:#{port}")
-                    sock = nil
-                end
-            end
-
-            if sock
-                Thread.new(sock) { |sock| write_loop(sock) } 
-                read_loop(sock)
-                disconnect(sock)
-            end
-            session.disconnected()
-        end
-
-        # This is called from random client threads
-        def send_data(data)
-            @write_queue.push(data)
-        end
-
-        # Since this runs in its very own thread and has no timers
-        # we can use boring blocking IO
-        def write_loop(socket)
-            Thread.current[:name] = "ZooKeeper::RubyIO::WriteLoop"
-            begin
-                until socket.closed?
-                    data = @write_queue.pop()
-                    if socket.write(data) != data.length()
-                        #TODO - will this really ever happen
-                        logger.warn("Incomplete write!")
-                    end
-                    logger.debug { "Sending: " + data.unpack("H*")[0] }
-                end
-                logger.debug { "Write loop finished" }
-            rescue Exception => ex
-                logger.warn("Exception in write loop",ex)
-                # Make sure we break out of the read loop
-                disconnect(socket)
-            end
-        end
-
-        def read_loop(socket)
-            Thread.current[:name] = "ZooKeeper::RubyIO::ReadLoop"
-            session.prime_connection(self) 
-            ping = 0
-            until socket.closed?
-                begin
-                    data = socket.read_nonblock(1024)
-                    logger.debug { "Received (#{data.length})" + data.unpack("H*")[0] }
-                    receive_data(data)
-                    ping = 0
-                rescue IO::WaitReadable
-                    select_result = IO.select([socket],[],[],session.ping_interval)
-                    unless select_result
-                        ping += 1
-                        # two timeouts in a row mean we need to send a ping
-                        case ping
-                        when 1 ;  session.ping()
-                        when 2
-                            logger.warn{"No response to ping in #{session.ping_interval}*2"}
-                            break
-                        end
-                    end
-                rescue EOFError
-                    # This is how we expect to end - send a close packet and the
-                    # server closes the socket
-                    logger.debug { "EOF reading from socket" }
-                    break
-                rescue Exception => ex
-                    logger.warn( "#{ex.class} exception in readloop",ex )
-                    break
-                end
-            end
-        end
-
-        # @api protocol
-        def receive_records(packet_io)
-            session.receive_records(packet_io)
-        end
-
-        private
-        def disconnect(socket)
-            socket.close if socket and !socket.closed?
-        rescue Exception => ex
-            #oh well
-            logger.debug("Exception closing socket",ex)
-        end
-
-    end #Class connection
-
-    module Binding
-        def connect(host,port,timeout)
-            Connection.new(host,port,timeout,self)
-        end
-    end
-end
-