zkruby 3.4.3 → 3.4.4.rc3

data/lib/zkruby/rubyio.rb

@@ -1,6 +1,5 @@
 require 'socket'
 require 'thread'
-require 'monitor'
 
 # Binding over standard ruby sockets
 #
@@ -23,6 +22,16 @@ require 'monitor'
 # 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
@@ -30,56 +39,92 @@ module ZooKeeper::RubyIO
         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()
 
-            # JRuby 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)
-            if RUBY_PLATFORM == "java"
-                begin
-                    sock = TCPSocket.new(host,port.to_i)
-                rescue Errno::ECONNREFUSED
-                    logger.warn("TCP Connection refused to #{host}:#{port}")
-                    sock = nil
-                end
-            else
+            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"))
-                sock.setsockopt(SOL_TCP, TCP_NODELAY,[0].pack("i_"))
+                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
-                    resp = IO.select(nil, [sock], nil, timeout)
+                  
                     begin
-                        sock.connect_nonblock(sockaddr)
-                    rescue Errno::ECONNREFUSED
-                        logger.warn("Connection refused to #{ host }:#{ port }")
+                        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
-                    rescue Errno::EISCONN
                     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
-            @socket = sock
-            Thread.new(sock) { |sock| write_loop(sock) } if sock
+            session.disconnected()
         end
 
-        # This is called from random client threads, but only within
-        # a @session.synchronized() block
+        # This is called from random client threads
         def send_data(data)
             @write_queue.push(data)
         end
 
-        # Since this runs in its very own thread
+        # 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
-                while socket
+                until socket.closed?
                     data = @write_queue.pop()
                     if socket.write(data) != data.length()
                         #TODO - will this really ever happen
@@ -87,35 +132,39 @@ module ZooKeeper::RubyIO
                     end
                     logger.debug { "Sending: " + data.unpack("H*")[0] }
                 end
+                logger.debug { "Write loop finished" }
             rescue Exception => ex
                 logger.warn("Exception in write loop",ex)
-                disconnect()
+                # Make sure we break out of the read loop
+                disconnect(socket)
             end
-
         end
 
-        def read_loop()
-            socket = @socket
+        def read_loop(socket)
+            Thread.current[:name] = "ZooKeeper::RubyIO::ReadLoop"
+            session.prime_connection(self) 
             ping = 0
-            while socket # effectively forever
+            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)
+                    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.synchronize { @session.ping() }
+                        when 1 ;  session.ping()
                         when 2
-                            logger.debug{"No response to ping in #{@session.ping_interval}*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
@@ -123,188 +172,27 @@ module ZooKeeper::RubyIO
                     break
                 end
             end
-            disconnect()
         end
 
-        def disconnect()
-            socket = @socket
-            @socket = nil
-            socket.close if socket
-        rescue Exception => ex
-            #oh well
-            logger.debug("Exception closing socket",ex)
-        end
-
-        # Protocol requirement
+        # @api protocol
         def receive_records(packet_io)
-            @session.synchronize { @session.receive_records(packet_io) }
+            session.receive_records(packet_io)
         end
 
-    end #Class connection
-
-    class Binding
-        include Slf4r::Logger
-        attr_reader :session
-        def self.available?
-            true
-        end
-
-        def self.context(&context_block)
-           yield Thread 
-        end
-
-        def initialize()
-            @event_queue = Queue.new()
-        end
-
-        def pop_event_queue()
-            queued = @event_queue.pop()
-            return false  unless queued
-            logger.debug { "Invoking #{queued[0]}" }
-            callback,*args = queued
-            callback.call(*args)
-            logger.debug { "Completed #{queued[0]}" }
-            return true
+        private
+        def disconnect(socket)
+            socket.close if socket and !socket.closed?
         rescue Exception => ex
-            logger.warn( "Exception in event thread", ex )
-            return true
-        end
-
-        def start(client,session)
-            @session = session
-            @session.extend(MonitorMixin)
-
-            # start the event thread
-            @event_thread = Thread.new() do
-                Thread.current[:name] = "ZooKeeper::RubyIO::EventLoop"
-
-                # In this thread, the current client is always this client!
-                Thread.current[ZooKeeper::CURRENT] = [client]
-                loop do
-                    break unless pop_event_queue() 
-                end
-            end
-
-            # and the read thread
-            Thread.new() do
-                begin
-                    Thread.current[:name] = "ZooKeeper::RubyIO::ReadLoop"
-                    conn = session.synchronize { session.start(); session.conn() } # will invoke connect 
-                    loop do
-                        break unless conn
-                        conn.read_loop()
-                        conn =  session.synchronize { session.disconnected(); session.conn() }
-                    end
-                    #event of death
-                    logger.debug("Pushing nil (event of death) to event queue")
-                    @event_queue.push(nil)
-                rescue Exception => ex
-                    logger.error( "Exception in session thread", ex )
-                end
-            end
-        end
-
-        # session callback, IO thread
-        def connect(host,port,delay,timeout)
-            sleep(delay)
-            conn = Connection.new(host,port,timeout,session)
-            session.synchronize() { session.prime_connection(conn) }
-        end
-
-
-        def close(&callback)
-            op = AsyncOp.new(self,&callback)
-            
-            session.synchronize do
-                    session.close() do |error,response|
-                        op.resume(error,response)
-                    end
-            end
-
-            op
-            
-        end
-
-        def queue_request(*args,&callback)
-
-            op = AsyncOp.new(self,&callback)
-            
-            session.synchronize do 
-                session.queue_request(*args) do |error,response|
-                    op.resume(error,response)                    
-                end
-            end
-
-            op
-        end
-
-        def event_thread?
-            Thread.current.equal?(@event_thread)
-        end
-
-        def invoke(*args)
-            @event_queue.push(args)
-        end
-
-    end #Binding
-
-    class AsyncOp < ::ZooKeeper::AsyncOp
-
-        def initialize(binding,&callback)
-            @mutex = Monitor.new
-            @cv = @mutex.new_cond()
-            @callback = callback
-            @rubyio = binding
-        end
-
-        def resume(error,response)
-            mutex.synchronize do
-                @error = error
-                @result = nil
-                begin
-                    @result = @callback.call(response) unless error
-                rescue StandardError => ex
-                    @error = ex
-                end
-               
-                if @error && @errback
-                    begin
-                        @result = @errback.call(@error) 
-                        @error = nil
-                    rescue StandardError => ex
-                        @error = ex
-                    end
-                end
-
-                cv.signal()
-            end
+            #oh well
+            logger.debug("Exception closing socket",ex)
         end
 
-        private
-            attr_reader :mutex, :cv, :error, :result
-
-        def set_error_handler(errback)
-            @errback = errback
-        end
-     
-        def wait_value()
-            if @rubyio.event_thread?
-                #Waiting in the event thread (eg made a synchronous call inside a callback)
-                #Keep processing events until we are resumed
-                until defined?(@result)
-                    break unless @rubyio.pop_event_queue()
-                end
-            else
-                mutex.synchronize do
-                    cv.wait()
-                end
-            end
+    end #Class connection
 
-            raise error if error
-            result
+    module Binding
+        def connect(host,port,timeout)
+            Connection.new(host,port,timeout,self)
         end
     end
+end
 
-end #ZooKeeper::RubyIO
-# Add our binding
-ZooKeeper.add_binding(ZooKeeper::RubyIO::Binding)