zmachine 0.2.1 → 0.3.0

data/lib/zmachine/connection_manager.rb

@@ -19,7 +19,7 @@ module ZMachine
 
     def idle?
       @new_connections.size == 0 and
-      @zmq_connections.none? {|c| c.channel.has_more? } # see comment in #process
+      @zmq_connections.none? {|c| c.channel.can_recv? } # see comment in #process
     end
 
     def shutdown
@@ -30,18 +30,17 @@ module ZMachine
 
     def bind(address, port_or_type, handler, *args, &block)
       ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", address: address, port_or_type: port_or_type) if ZMachine.debug
-      connection = build_connection(handler, *args, &block)
-      connection.bind(address, port_or_type)
+      connection = build_connection(handler, *args)
+      connection.bind(address, port_or_type, &block)
       @new_connections << connection
       connection
     end
 
     def connect(address, port_or_type, handler, *args, &block)
       ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", address: address, port_or_type: port_or_type) if ZMachine.debug
-      connection = build_connection(handler, *args, &block)
-      connection.connect(address, port_or_type)
+      connection = build_connection(handler, *args)
+      connection.connect(address, port_or_type, &block)
       @new_connections << connection
-      yield connection if block_given?
       connection
     rescue java.nio.channels.UnresolvedAddressException
       raise ZMachine::ConnectionError.new('unable to resolve server address')
@@ -55,26 +54,30 @@ module ZMachine
         process_connection(it.next.attachment)
         it.remove
       end
-      # super ugly, but ZMQ only triggers the FD if and only if you have read
-      # every message from the socket. under load however there will always be
-      # new messages in the mailbox between last recv and next select, which
-      # causes the FD never to be triggered again.
-      # the only mitigation strategy i came up with is iterating over all channels :(
+      # super ugly, but ZMQ only triggers the FD if and only if you
+      # have read every message from the socket. under load however
+      # there will always be new messages in the mailbox between last
+      # recv and next select, which causes the FD never to be
+      # triggered again.
+      # the only mitigation strategy i came up with is iterating over all
+      # channels. performance impact shouldn't be too huge, since ZMQ takes
+      # care of all the multiplexing and we only have a small amount of ZMQ
+      # connections in the reactor
       @zmq_connections.each do |connection|
-        connection.readable! if connection.channel.has_more?
+        connection.readable! if connection.channel.can_recv?
       end
     end
 
     def process_connection(connection)
       new_connection = connection.process_events
       @new_connections << new_connection if new_connection
-    rescue IOException
-      close_connection(connection)
+    rescue IOException => e
+      close_connection(connection, e)
     end
 
-    def close_connection(connection)
-      ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", connection: connection) if ZMachine.debug
-      @unbound_connections << connection
+    def close_connection(connection, reason = nil)
+      ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", connection: connection, reason: reason.inspect) if ZMachine.debug
+      @unbound_connections << [connection, reason]
     end
 
     def add_new_connections
@@ -83,10 +86,12 @@ module ZMachine
         begin
           connection.register(@selector)
           @connections << connection
-          @zmq_connections << connection if connection.channel.is_a?(ZMQChannel)
+          if connection.channel.is_a?(ZMQChannel)
+            @zmq_connections << connection
+            connection.connection_completed
+          end
         rescue ClosedChannelException => e
-          ZMachine.logger.exception(e, "failed to add connection")
-          @unbound_connections << connection
+          @unbound_connections << [connection, e]
         end
       end
       @new_connections.clear
@@ -101,7 +106,11 @@ module ZMachine
         begin
           @connections.delete(connection)
           @zmq_connections.delete(connection)
-          connection.unbind
+          if connection.method(:unbind).arity != 0
+            connection.unbind(reason)
+          else
+            connection.unbind
+          end
           connection.close
         rescue Exception => e
           ZMachine.logger.exception(e, "failed to unbind connection") if ZMachine.debug
@@ -112,16 +121,16 @@ module ZMachine
 
     private
 
-    def build_connection(handler, *args, &block)
+    def build_connection(handler, *args)
       if handler and handler.is_a?(Class)
-        handler.new(*args, &block)
+        handler.new(*args)
       elsif handler and handler.is_a?(Connection)
         # already initialized connection on reconnect
         handler
       elsif handler
-        connection_from_module(handler).new(*args, &block)
+        connection_from_module(handler).new(*args)
       else
-        Connection.new(*args, &block)
+        Connection.new(*args)
       end
     end
 

data/lib/zmachine/hashed_wheel.rb

@@ -27,13 +27,13 @@ module ZMachine
 
     def initialize(number_of_slots, tick_length, start_time = System.nano_time)
       @slots = Array.new(number_of_slots) { [] }
-      @tick_length = tick_length * 1_000_000
+      @tick_length = tick_length * 1_000_000_000
       @last = start_time
       @current_tick = 0
     end
 
     def add(timeout, &block)
-      timeout *= 1_000_000 # ms to ns
+      timeout *= 1_000_000_000 # s to ns
       ticks = timeout / @tick_length
       slot  = (@current_tick + ticks) % @slots.length
       HashedWheelTimeout.new(System.nano_time + timeout, &block).tap do |hwt|
@@ -41,14 +41,15 @@ module ZMachine
       end
     end
 
-    def reset(time = System.nano_time)
+    def reset(time = nil)
       @slots = Array.new(@slots.length) { [] }
       @current_tick = 0
-      @last = time
+      @last = time || System.nano_time
     end
 
     # returns all timeouts
-    def advance(now = System.nano_time)
+    def advance(now = nil)
+      now ||= System.nano_time
       passed_ticks = (now - @last) / @tick_length
       result = []
       begin

data/lib/zmachine/reactor.rb

@@ -40,7 +40,7 @@ module ZMachine
       @next_tick_queue = ConcurrentLinkedQueue.new
       @running = false
       @shutdown_hooks = []
-      @wheel = HashedWheel.new(512, 10)
+      @wheel = HashedWheel.new(512, 0.01)
     end
 
     def add_shutdown_hook(&block)
@@ -53,7 +53,7 @@ module ZMachine
       callback = args.shift || block
       ZMachine.logger.debug("zmachine:reactor:#{__method__}", interval: interval, callback: callback) if ZMachine.debug
       return unless callback
-      @wheel.add((interval.to_f * 1000).to_i, &callback)
+      @wheel.add(interval, &callback)
     end
 
     def bind(server, port_or_type=nil, handler=nil, *args, &block)
@@ -62,8 +62,9 @@ module ZMachine
       @connection_manager.bind(server, port_or_type, handler, *args, &block)
     end
 
-    def close_connection(connection)
-      @connection_manager.close_connection(connection)
+    def close_connection(connection, reason = nil)
+      return true unless @connection_manager
+      @connection_manager.close_connection(connection, reason)
     end
 
     def connect(server, port_or_type=nil, handler=nil, *args, &block)
@@ -129,9 +130,9 @@ module ZMachine
     def run_reactor
       ZMachine.logger.debug("zmachine:reactor:#{__method__}") if ZMachine.debug
       run_deferred_callbacks
-      break unless @run_reactor
+      return unless @run_reactor
       run_timers
-      break unless @run_reactor
+      return unless @run_reactor
       @connection_manager.cleanup
       if @connection_manager.idle?
         ZMachine.logger.debug("zmachine:reactor:#{__method__}", select: @heartbeat_interval) if ZMachine.debug
@@ -149,6 +150,7 @@ module ZMachine
 
     def stop_event_loop
       @run_reactor = false
+      @connection_manager.shutdown
       wakeup
     end
 
@@ -173,7 +175,7 @@ module ZMachine
     def run_timers
       ZMachine.logger.debug("zmachine:reactor:#{__method__}") if ZMachine.debug
       @wheel.advance.each do |timeout|
-        ZMachine.logger.debug("zmachine:reactor:#{__method__}", callback: timeout.callback) if ZMachine.debug
+        ZMachine.logger.info("zmachine:reactor:#{__method__}", callback: timeout.callback) if ZMachine.debug
         timeout.callback.call
       end
     end

data/lib/zmachine/tcp_channel.rb

@@ -13,6 +13,7 @@ module ZMachine
     end
 
     def bind(address, port)
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
       address = InetSocketAddress.new(address, port)
       @socket = ServerSocketChannel.open
       @socket.configure_blocking(false)
@@ -20,10 +21,11 @@ module ZMachine
     end
 
     def bound?
-      @socket.is_a?(ServerSocketChannel) and @socket.bound?
+      @socket.is_a?(ServerSocketChannel) && @socket.bound?
     end
 
     def accept
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
       client_socket = @socket.accept
       return unless client_socket
       client_socket.configure_blocking(false)
@@ -33,6 +35,7 @@ module ZMachine
     end
 
     def connect(address, port)
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
       address = InetSocketAddress.new(address, port)
       @socket = SocketChannel.open
       @socket.configure_blocking(false)
@@ -51,9 +54,9 @@ module ZMachine
     end
 
     def finish_connecting
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
       return unless connection_pending?
-      @socket.finish_connect # XXX: finish_connect might return false
-      return true
+      @socket.finish_connect
     end
 
     def connected?
@@ -61,50 +64,20 @@ module ZMachine
     end
 
     def read_inbound_data
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
       buffer = @inbound_buffer
       buffer.clear
       raise IOException.new("EOF") if @socket.read(buffer) == -1
       buffer.flip
       return if buffer.limit == 0
-      String.from_java_bytes(buffer.array[buffer.position...buffer.limit])
+      data = buffer.array[buffer.position...buffer.limit]
+      data = String.from_java_bytes(data) unless @raw
+      data
     end
 
-    def send_data(data)
-      raise RuntimeError.new("send_data called after close") if @close_scheduled
-      return unless data
-      data = data.to_java_bytes if data.is_a?(String) # EM compat
-      buffer = ByteBuffer.wrap(data)
-      if buffer.has_remaining
-        @outbound_queue << buffer
-      end
-    end
-
-    def write_outbound_data
-      while can_send?
-        buffer = @outbound_queue.first
-        @socket.write(buffer) if buffer.has_remaining
-        # Did we consume the whole outbound buffer? If yes,
-        # pop it off and keep looping. If no, the outbound network
-        # buffers are full, so break out of here.
-        if buffer.remaining == 0
-          @outbound_queue.shift
-        else
-          break
-        end
-      end
-
-      if can_send?
-        # network buffers are full
-        return false
-      end
-
-      close if @close_scheduled
-      return true
-    end
-
-    def close(after_writing = false)
-      super
-      @socket.close unless can_send?
+    def close!
+      ZMachine.logger.debug("zmachine:tcp_channel:#{__method__}", channel: self) if ZMachine.debug
+      @socket.close
     end
 
     def closed?

data/lib/zmachine/timers.rb

@@ -1,61 +1,33 @@
 module ZMachine
-  # Creates a one-time timer
-  #
-  #  timer = ZMachine::Timer.new(5) do
-  #    # this will never fire because we cancel it
-  #  end
-  #  timer.cancel
-  #
   class Timer
-    # Create a new timer that fires after a given number of seconds
-    def initialize(interval, callback=nil, &block)
-      @signature = ZMachine.add_timer(interval, callback || block)
-    end
 
-    # Cancel the timer
-    def cancel
-      ZMachine.cancel_timer(@signature)
-    end
-  end
+    attr_accessor :interval
 
-  # Creates a periodic timer
-  #
-  # @example
-  #  n = 0
-  #  timer = ZMachine::PeriodicTimer.new(5) do
-  #    puts "the time is #{Time.now}"
-  #    timer.cancel if (n+=1) > 5
-  #  end
-  #
-  class PeriodicTimer
-    # Create a new periodic timer that executes every interval seconds
     def initialize(interval, callback=nil, &block)
       @interval = interval
-      @code = callback || block
-      @cancelled = false
-      @work = method(:fire)
+      @callback = callback || block
       schedule
     end
 
-    # Cancel the periodic timer
-    def cancel
-      @cancelled = true
+    def schedule
+      @timer = ZMachine.add_timer(@interval, method(:fire))
     end
 
-    # Fire the timer every interval seconds
-    attr_accessor :interval
+    def fire
+      @callback.call
+    end
 
-    # @private
-    def schedule
-      ZMachine.add_timer(@interval, @work)
+    def cancel
+      @timer.cancel
     end
+  end
+
+  class PeriodicTimer < Timer
 
-    # @private
     def fire
-      unless @cancelled
-        @code.call
-        schedule
-      end
+      super
+      schedule
     end
+
   end
 end

data/lib/zmachine/zmq_channel.rb

@@ -1,4 +1,5 @@
-require 'zmachine/jeromq-0.3.0-SNAPSHOT.jar'
+require 'zmachine/jeromq-0.3.2-SNAPSHOT.jar'
+java_import org.zeromq.ZMsg
 java_import org.zeromq.ZMQ
 java_import org.zeromq.ZMQException
 
@@ -9,35 +10,39 @@ class ZMQ
   class Socket
     # for performance reason we alias the method here (otherwise it uses reflections all the time!)
     # super ugly, since we need to dynamically infer the java class of byte[]
+    java_alias :send_byte_buffer, :sendByteBuffer, [Java::JavaNio::ByteBuffer.java_class, Java::int]
     java_alias :send_byte_array, :send, [[].to_java(:byte).java_class, Java::int]
     java_alias :recv_byte_array, :recv, [Java::int]
+
+    def write(buffer)
+      bytes = send_byte_buffer(buffer, 0)
+      buffer.position(buffer.position + bytes)
+    end
   end
 end
 
 module ZMachine
   class ZMQChannel < Channel
 
-    def initialize(type)
-      super()
-      @socket = ZMachine.context.create_socket(type)
-      @bound = false
-      @connected = false
-      @closed = false
-    end
+    extend Forwardable
 
-    def identity=(v)
-      @socket.identity = v if @socket
-    end
-    def identity
-      @socket ? @socket.identity : nil
+    def_delegator :@socket, :identity
+    def_delegator :@socket, :identity=
+
+    def initialize
+      super
+      @raw = true
     end
 
     def selectable_fd
       @socket.fd
     end
 
-    def bind(address, port = nil)
+    def bind(address, type)
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
       @bound = true
+      @connected = true
+      @socket = ZMachine.context.create_socket(type)
       @socket.bind(address)
     end
 
@@ -45,13 +50,26 @@ module ZMachine
       @bound
     end
 
-    def connect(address)
-      @connected = true
+    def accept
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
+      self
+    end
+
+    def connect(address, type)
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
+      @connection_pending = true
+      @socket = ZMachine.context.create_socket(type)
       @socket.connect(address)
     end
 
     def connection_pending?
-      false
+      @connection_pending
+    end
+
+    def finish_connecting
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
+      return unless connection_pending?
+      @connected = true
     end
 
     def connected?
@@ -59,71 +77,40 @@ module ZMachine
     end
 
     def read_inbound_data
-      data = [@socket.recv_byte_array(0)]
-      while @socket.hasReceiveMore
-        data << @socket.recv_byte_array(0)
-      end
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
+      data = ZMsg.recv_msg(@socket)
+      data = String.from_java_bytes(data.first.data) unless @raw
       data
     end
 
-    def send_data(data)
-      parts, last = data[0..-2], data.last
-      parts.each do |part|
-        @socket.send_byte_array(part, ZMQ::SNDMORE | ZMQ::DONTWAIT)
-      end
-      @socket.send_byte_array(last, ZMQ::DONTWAIT)
-    rescue ZMQException
-      @outbound_queue << data
-    end
-
-    # to get around iterating over an array in #send_data we pass message parts
-    # as arguments
     def send1(a)
       @socket.send_byte_array(a, ZMQ::DONTWAIT)
     end
 
     def send2(a, b)
-      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT)
+      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
       @socket.send_byte_array(b, ZMQ::DONTWAIT)
     end
 
     def send3(a, b, c)
-      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT)
-      @socket.send_byte_array(b, ZMQ::SNDMORE | ZMQ::DONTWAIT)
+      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
+      @socket.send_byte_array(b, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
       @socket.send_byte_array(c, ZMQ::DONTWAIT)
     end
 
     def send4(a, b, c, d)
-      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT)
-      @socket.send_byte_array(b, ZMQ::SNDMORE | ZMQ::DONTWAIT)
-      @socket.send_byte_array(c, ZMQ::SNDMORE | ZMQ::DONTWAIT)
+      @socket.send_byte_array(a, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
+      @socket.send_byte_array(b, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
+      @socket.send_byte_array(c, ZMQ::SNDMORE | ZMQ::DONTWAIT) and
       @socket.send_byte_array(d, ZMQ::DONTWAIT)
     end
 
-    def has_more?
-      @socket.events & ZMQ::Poller::POLLIN == ZMQ::Poller::POLLIN
-    end
-
-    def can_send?
-      super and (@socket.events & ZMQ::Poller::POLLOUT == ZMQ::Poller::POLLOUT)
-    end
-
-    def write_outbound_data
-      while can_send?
-        data = @outbound_queue.shift
-        send_data(data)
-      end
-
-      close if @close_scheduled
-      return true
-    end
-
-    def close(after_writing = false)
-      super
+    def close!
+      ZMachine.logger.debug("zmachine:zmq_channel:#{__method__}", channel: self) if ZMachine.debug
       @closed = true
       @connected = false
       @bound = false
-      ZMachine.context.destroySocket(@socket) unless can_send?
+      ZMachine.context.destroySocket(@socket)
     end
 
     def closed?
@@ -134,5 +121,10 @@ module ZMachine
       raise RuntimeError.new("ZMQChannel has no peer")
     end
 
+    # see comment in ConnectionManager#process
+    def can_recv?
+      @socket.events & ZMQ::Poller::POLLIN == ZMQ::Poller::POLLIN
+    end
+
   end
 end