zmachine 0.1.1 → 0.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODFlZWJhODg3YmM5NWMxYmJmZmRmNmM5ZGI0N2NkMzIzNWU3YjEwZg==
+  data.tar.gz: !binary |-
+    NGMyYTk4ZmIwODI5OWZlMjY1ZDQxYjRkYTBlZGJiZjAyZGY0MDY4Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YTVjMmVhODBmZjU3NTA4MmQ4MDBkOTRlZmE4OTMzNjA4ZWM4NjgwZmM2ZWVm
+    YWRlYTM0Mzg0NTlhYzYwYzgyOWIwZmMzMzcyZTEzNDU2MjFjNGQyYjliMmFh
+    YzJmMWYwZWU5MTdjYmJmZjk0ZDgwZmQ2YzZhOGQxZjdmNTNmZTA=
+  data.tar.gz: !binary |-
+    OGRmZjQ3YWI2NTllOWI2MzQzODVhOGVjYzAzMjI5ZDgwNTQ3NTU4MjM4NjVk
+    Yjk5MzU0MmJmM2QwNjUxYzllZTZlMWIyMTVlMGM5OTE1YWZmOTA1OTIzZGRm
+    Y2VjYjI4N2JkNzRjOTcxNDgzMTA0NTU1YmM0ZWYwOWFmMzQ1M2I=

data/lib/zmachine/acceptor.rb

@@ -4,8 +4,16 @@ module ZMachine
     attr_reader :args
     attr_reader :callback
 
-    def initialize(channel, klass, *args, &block)
-      @klass, @args, @callback = klass, args, block
+    def initialize(channel, klass, *args )
+      @klass, @args, @callback = klass, args[0...-1], args.last
+      @channel = channel
+    end
+
+    def unbind
+    end
+
+    def close
+      @channel.close
     end
 
   end

data/lib/zmachine/channel.rb

@@ -1,13 +1,42 @@
 module ZMachine
   class Channel
 
-    attr_reader :socket
-    attr_reader :selector
+    attr_accessor :socket
+    attr_reader   :selector
     attr_accessor :handler
+    attr_accessor :reactor
+
+    attr_reader :comm_inactivity_timeout
+    attr_reader :last_comm_activity
 
     def initialize(selector)
       @selector = selector
       @outbound_queue = []
+      @comm_inactivity_timeout = 0
+      @timedout = false
+      mark_active!
+    end
+
+    # assigned in seconds!!
+    def comm_inactivity_timeout=(value)
+      # we are in nanos
+      @comm_inactivity_timeout = value * 1000_000_000
+    end
+
+    def mark_active!
+      @last_comm_activity = System.nano_time
+    end
+
+    def timedout?
+      @timedout
+    end
+
+    def timedout!
+      @timedout = true
+    end
+
+    def was_active?(now)
+      @last_comm_activity + @comm_inactivity_timeout >= now
     end
 
   end

data/lib/zmachine/connection.rb

@@ -30,9 +30,20 @@ module ZMachine
     def receive_data(data)
     end
 
+    def send3(a,b,c)
+      @channel.send3 a,b,c
+    end
+    def send2(a,b)
+      @channel.send2 a,b
+    end
+
     def unbind
     end
 
+    def reconnect(server, port)
+      ZMachine.reconnect server, port, self
+    end
+
     # public API
 
     def_delegator :@channel, :close_connection
@@ -42,9 +53,11 @@ module ZMachine
     end
 
     def comm_inactivity_timeout
+      channel.comm_inactivity_timeout
     end
 
     def comm_inactivity_timeout=(value)
+      channel.comm_inactivity_timeout = value
     end
 
     alias :set_comm_inactivity_timeout :comm_inactivity_timeout=
@@ -180,7 +193,7 @@ module ZMachine
     private
 
     def _not_implemented
-      raise RuntimeError.new("API call not implemented!")
+      raise RuntimeError.new("API call not implemented! #{caller[0]}")
     end
   end
 end

data/lib/zmachine/hashed_wheel.rb

@@ -0,0 +1,77 @@
+module ZMachine
+
+  class HashedWheelTimeout
+    attr_accessor :round
+    attr_reader :deadline
+    attr_reader :callback
+    def initialize(round, deadline, &block)
+      @round = round
+      @deadline = deadline
+      @callback = block
+    end
+  end
+
+  class HashedWheel
+
+    attr_reader :slots
+    attr_accessor :last
+
+    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
+      @last = start_time
+      @current_tick = 0
+
+      @next = nil
+    end
+
+    def next_deadline
+      return Float::INFINITY if !@next
+      @next.deadline
+    end
+
+    def add(timeout, &block)
+      timeout *= 1_000_000 # ms to ns
+      idx =  (timeout / @tick_length) % @slots.length
+      round = (timeout / @tick_length) / @slots.length
+      @slots[idx] << hwt = HashedWheelTimeout.new(round, System.nano_time + timeout, &block)
+      if !@next
+        @next = hwt
+      else
+        @next = hwt if @next.deadline > hwt.deadline
+      end
+      hwt
+    end
+
+    def reset(time = System.nano_time)
+      @slots = Array.new(@slots.length) { [] }
+      @current_tick = 0
+      @last = time
+    end
+
+    # returns all timeouts
+    def advance(now = System.nano_time)
+      # how many tickts have passed?
+      passed_ticks = (now - @last) / @tick_length
+      round = 0
+      result = []
+      begin
+        q, @current_tick = @current_tick.divmod slots.length
+        round += q
+        # collect timeouts
+         @slots[@current_tick].delete_if do |timeout|
+          timeout.round -= round
+          result << timeout if timeout.round <= 0 && timeout.deadline < now
+        end
+        @current_tick += 1
+        passed_ticks -= 1
+      end while passed_ticks > 0
+      @last = now
+      result
+    end
+
+  end
+end
+
+
+

data/lib/zmachine/reactor.rb

@@ -1,3 +1,4 @@
+java_import java.lang.System
 java_import java.io.FileDescriptor
 java_import java.io.IOException
 java_import java.net.InetSocketAddress
@@ -17,11 +18,46 @@ java_import org.zeromq.ZContext
 require 'zmachine/acceptor'
 require 'zmachine/tcp_channel'
 require 'zmachine/zmq_channel'
+require 'zmachine/hashed_wheel'
 
 module ZMachine
+
+  class NotReactorOwner < Exception
+  end
+
+  class NoReactorError < Exception
+  end
+
   class Reactor
 
+    @mutex = Mutex.new
+
+    def self.register_reactor(reactor)
+      @mutex.synchronize do
+        @reactors ||= []
+        @reactors << reactor
+      end
+    end
+
+    def self.terminate_all_reactors
+      # should have a lock ....
+      @mutex.synchronize do
+        @reactors.each(&:stop_event_loop)
+        @reactors.clear
+      end
+    end
+
+    def self.unregister_reactor(reactor)
+      @mutex.synchronize do
+        @reactors.delete(reactor)
+      end
+    end
+
     def initialize
+      #  a 10 ms tick wheel with a 512 slots => ~5s for a round
+      @wheel = HashedWheel.new(512, 10)
+      @last = now = System.nano_time
+      @heartbeat_interval = 50_000_000 # 50 ms
       @timers = TreeMap.new
       @timer_callbacks = {}
       @channels = []
@@ -40,13 +76,23 @@ module ZMachine
       @shutdown_hooks << block
     end
 
+    def xadd_timer(*args, &block)
+      check_reactor_thread
+      interval = args.shift
+      callback = args.shift || block
+      return unless callback
+      @wheel.add((interval.to_f * 1000).to_i, &callback)
+    end
+
+
     def add_timer(*args, &block)
+      check_reactor_thread
       interval = args.shift
       callback = args.shift || block
       return unless callback
 
       signature = next_signature
-      deadline = java.util.Date.new.time + (interval.to_f * 1000).to_i
+      deadline = System.nano_time + (interval.to_f * 1000_000_000).to_i
 
       if @timers.contains_key(deadline)
         @timers.get(deadline) << signature
@@ -59,6 +105,12 @@ module ZMachine
       signature
     end
 
+    def unbind_channel(channel)
+      channel.handler = nil
+      ZMachine.logger.debug "zmachine:unbind_channel", channel:channel if ZMachine.debug
+      @unbound_channels << channel
+    end
+
     def cancel_timer(timer_or_sig)
       if timer_or_sig.respond_to?(:cancel)
         timer_or_sig.cancel
@@ -70,11 +122,21 @@ module ZMachine
 
     def connect(server, port_or_type=nil, handler=nil, *args, &block)
       ZMachine.logger.debug("zmachine:#{__method__}", server: server, port_or_type: port_or_type) if ZMachine.debug
+      check_reactor_thread
       if server.nil? or server =~ %r{\w+://}
         _connect_zmq(server, port_or_type, handler, *args, &block)
       else
         _connect_tcp(server, port_or_type, handler, *args, &block)
       end
+    rescue java.nio.channels.UnresolvedAddressException
+      raise ZMachine::ConnectionError.new('unable to resolve server address')
+    end
+
+    def reconnect(server, port, handler)
+      # No reconnect for zmq ... handled by zmq itself anyway
+      return if handler && handler.channel.is_a?(ZMQChannel) #
+      # TODO : we might want to check if this connection is really dead?
+      connect server, port, handler
     end
 
     def connection_count
@@ -87,7 +149,7 @@ module ZMachine
 
     def next_tick(callback=nil, &block)
       @next_tick_queue << (callback || block)
-      signal_loopbreak if running?
+      signal_loopbreak if reactor_running?
     end
 
     def run(callback=nil, shutdown_hook=nil, &block)
@@ -98,9 +160,16 @@ module ZMachine
       add_shutdown_hook(shutdown_hook) if shutdown_hook
 
       begin
+        # list of active reactors
+        Reactor.register_reactor(self)
+
         @running = true
 
-        add_timer(0, @callback) if @callback
+        if @callback
+          add_timer(0) do
+            @callback.call(self)
+          end
+        end
 
         @selector = Selector.open
         @run_reactor = true
@@ -111,11 +180,20 @@ module ZMachine
           break unless @run_reactor
           run_timers
           break unless @run_reactor
+          # advance_timer_wheel
+          # break unless @run_reactor
+          remove_timed_out_channels
           remove_unbound_channels
           check_io
           add_new_channels
           process_io
         end
+      rescue => e
+        puts e.message
+        raise e
+      #  # maybe add error check callback here
+      #  puts "FATAL reactor died : #{e.message}"
+      #  puts e.backtrace
       ensure
         ZMachine.logger.debug("zmachine:#{__method__}", stop: :selector) if ZMachine.debug
         @selector.close rescue nil
@@ -127,8 +205,16 @@ module ZMachine
         @shutdown_hooks.pop.call until @shutdown_hooks.empty?
         @next_tick_queue = ConcurrentLinkedQueue.new
         @running = false
+        Reactor.unregister_reactor(self)
         ZMachine.logger.debug("zmachine:#{__method__}", stop: :zcontext) if ZMachine.debug
         ZMachine.context.destroy
+        ZMachine.clear_current_reactor
+      end
+    end
+
+    def advance_timer_wheel
+      @wheel.advance.each do |timeout|
+        timeout.callback.call
       end
     end
 
@@ -156,11 +242,18 @@ module ZMachine
 
     private
 
+    def check_reactor_thread
+      raise NoReactorError if !Thread.current[:reactor]
+      raise NotReactorOwner if Thread.current[:reactor] != self
+    end
+
+
     def _bind_tcp(address, port, handler, *args, &block)
       klass = _klass_from_handler(Connection, handler)
       channel = TCPChannel.new(@selector)
       channel.bind(address, port)
-      add_channel(channel, Acceptor, klass, *args, &block)
+      add_channel(channel, Acceptor, klass, *(args+[block]) )
+      channel.handler
     end
 
     def _bind_zmq(address, type, handler, *args, &block)
@@ -168,6 +261,7 @@ module ZMachine
       channel = ZMQChannel.new(type, @selector)
       channel.bind(address)
       add_channel(channel, klass, *args, &block)
+      channel.handler
     end
 
     def _connect_tcp(address, port, handler=nil, *args, &block)
@@ -176,6 +270,8 @@ module ZMachine
       channel.connect(address, port)
       channel.connect_pending = true
       add_channel(channel, klass, *args, &block)
+      channel.mark_active!
+      channel.handler
     end
 
     def _connect_zmq(address, type, handler=nil, *args, &block)
@@ -184,28 +280,43 @@ module ZMachine
       add_channel(channel, klass, *args, &block)
       channel.connect(address)
       channel.handler.connection_completed
-      channel
+      channel.handler
     end
 
     def check_io
+
+      now = System.nano_time
+
       if @new_channels.size > 0
         timeout = -1
       elsif !@timers.empty?
-        now = java.util.Date.new.time
         timer_key = @timers.first_key
-        timeout = timer_key - now
+        timeout = (timer_key - now)
         timeout = -1 if timeout <= 0
       else
+       # puts "hb = #{@heartbeat_interval}"
+        #timeout = (@heartbeat_interval - (now - @last)) / 1_000_000
         timeout = 0
       end
 
-      if @channels.any?(&:has_more?)
-        timeout = -1
+      # timeout = @heartbeat_interval - (now - @last)
+      # wnd = @wheel.next_deadline - now
+      # timeout = wnd if timeout > wnd
+      # timeout = -1 if timeout == 0
+      # @last = now
+
+      # sucks a bit ...
+      timeout = -1 if @channels.any?(&:has_more?) # iterate all channels????
+
+      # we have to convert the timeout from ns to ms
+      if timeout > 0
+        timeout /= 1_000_000
+        timeout = -1 if timeout == 0 # check if it would be below 1ms .. 0 would be an indefinite wait but we want to select NOW
       end
 
       ZMachine.logger.debug("zmachine:#{__method__}", timeout: timeout) if ZMachine.debug
 
-      if timeout == -1
+      if timeout < 0
         @selector.select_now
       else
         @selector.select(timeout)
@@ -218,7 +329,6 @@ module ZMachine
       while it.has_next
         selected_key = it.next
         it.remove
-
         if selected_key.connectable?
           is_connectable(selected_key.attachment)
         elsif selected_key.acceptable?
@@ -237,42 +347,66 @@ module ZMachine
 
     def is_acceptable(channel)
       ZMachine.logger.debug("zmachine:#{__method__}", channel: channel) if ZMachine.debug
-      client_channel = channel.accept(next_signature)
+      client_channel = channel.accept
       acceptor = channel.handler
-      add_channel(client_channel, acceptor.klass, *acceptor.args, &acceptor.callback)
-    rescue IOException
+      new_channel = add_channel(client_channel, acceptor.klass, *acceptor.args, &acceptor.callback)
+      new_channel.mark_active!
+      new_channel
+    rescue IOException => e
+      ZMachine.logger.debug("zmachine:#{__method__} unbind", channel: channel, e:e.message) if ZMachine.debug
       channel.close
     end
 
     def is_readable(channel)
       ZMachine.logger.debug("zmachine:#{__method__}", channel: channel) if ZMachine.debug
+      channel.mark_active!
       data = channel.read_inbound_data(@read_buffer)
       channel.handler.receive_data(data) if data
-    rescue IOException
+    rescue IOException => e
+      ZMachine.logger.debug("zmachine:#{__method__} unbind", channel: channel, e:e.message) if ZMachine.debug
       @unbound_channels << channel
     end
 
     def is_writable(channel)
       ZMachine.logger.debug("zmachine:#{__method__}", channel: channel) if ZMachine.debug
+      channel.mark_active!
       @unbound_channels << channel unless channel.write_outbound_data
-    rescue IOException
+    rescue IOException => e
+      ZMachine.logger.debug("zmachine:#{__method__} unbind", channel: channel, e:e.message) if ZMachine.debug
       @unbound_channels << channel
     end
 
     def is_connectable(channel)
+      channel.mark_active!
       ZMachine.logger.debug("zmachine:#{__method__}", channel: channel) if ZMachine.debug
-      channel.finish_connecting
-      channel.handler.connection_completed
-    rescue IOException
+      result = channel.finish_connecting
+      if !result
+        ZMachine.logger.warn("zmachine:finish_connecting failed", channel: channel) if !result
+        @unbound_channels << channel
+      else
+        channel.handler.connection_completed
+      end
+    rescue IOException => e
+      ZMachine.logger.debug("zmachine:#{__method__} unbind", channel: channel, e:e.message) if ZMachine.debug
       @unbound_channels << channel
     end
 
-    def add_channel(channel, klass, *args, &block)
+    def add_channel(channel, klass_or_instance, *args, &block)
       ZMachine.logger.debug("zmachine:#{__method__}", channel: channel) if ZMachine.debug
-      channel.handler = klass.new(channel, *args)
+      if klass_or_instance.is_a?(Connection)
+        # if klass_or_instance is not a class but already an instance
+        channel.handler = klass_or_instance
+        klass_or_instance.channel = channel
+      else
+        channel.handler = klass_or_instance.new(channel, *args)
+      end
+      channel.reactor = self
       @new_channels << channel
       block.call(channel.handler) if block
       channel
+    rescue => e
+      puts "ERROR adding channel #{e.message}"
+      puts e.backtrace
     end
 
     def add_new_channels
@@ -280,17 +414,40 @@ module ZMachine
         begin
           channel.register
           @channels << channel
-        rescue ClosedChannelException
+        rescue ClosedChannelException => e
+          puts "UNBIND on add_channel #{e.message}"
           @unbound_channels << channel
         end
       end
       @new_channels.clear
     end
 
+    def remove_timed_out_channels
+      # TODO : we want to replace all of our timer handling with hashed wheels in the future
+      now = now = System.nano_time
+      @channels.each do |channel|
+        next if channel.comm_inactivity_timeout == 0
+        if !channel.was_active?(now)
+          ZMachine.logger.debug("zmachine:#{__method__} unbind", channel: channel, now:now,last:channel.last_comm_activity, delta:(now - channel.last_comm_activity), timeout:timeout=channel.comm_inactivity_timeout) if ZMachine.debug
+          channel.timedout!
+          @unbound_channels << channel
+        end
+      end
+    end
+
     def remove_unbound_channels
+      return if @unbound_channels.empty?
       @unbound_channels.each do |channel|
-        channel.handler.unbind if channel.handler
-        channel.close
+        reason = nil
+        channel, reason = *channel if channel.is_a?(Array)
+        begin
+          # puts "#{channel} unbound"
+          @channels.delete(channel)
+          channel.handler.unbind if channel.handler
+          channel.close
+        rescue Exception => e
+          ZMachine.logger.debug("zmachine:#{__method__} unbind error", channel: channel, reason:reason, klass:e.class, msg:e.message) if ZMachine.debug
+        end
       end
       @unbound_channels.clear
     end
@@ -302,21 +459,20 @@ module ZMachine
         begin
           size -= 1
           callback.call
-        ensure
-          ZMachine.next_tick {} if $!
+        # ensure
+        #   ZMachine.next_tick {} if $!
         end
       end
     end
 
+    # TODO : we should definitly optimize periodic timers ... right now they are wasting a hell of cycle es they are recreated on every invocation
     def run_timers
-      now = java.util.Date.new.time
+      now = System.nano_time
       until @timers.empty?
         timer_key = @timers.first_key
         break if timer_key > now
-
         signatures = @timers.get(timer_key)
         @timers.remove(timer_key)
-
         # Fire all timers at this timestamp
         signatures.each do |signature|
           callback = @timer_callbacks.delete(signature)
@@ -338,8 +494,11 @@ module ZMachine
     def _klass_from_handler(klass = Connection, handler = nil)
       if handler and handler.is_a?(Class)
         handler
+      elsif handler and handler.is_a?(Connection)
+        # can happen on reconnect
+        handler
       elsif handler
-        _handler_from_klass(klass, handler)
+        _handler_from_module(klass, handler)
       else
         klass
       end

data/lib/zmachine/tcp_channel.rb

@@ -11,6 +11,7 @@ module ZMachine
       super(selector)
       @close_scheduled = false
       @connect_pending = false
+      @server_socket   = false
     end
 
     def register
@@ -18,6 +19,7 @@ module ZMachine
     end
 
     def bind(address, port)
+      @server_socket = true
       address = InetSocketAddress.new(address, port)
       @socket = ServerSocketChannel.open
       @socket.configure_blocking(false)
@@ -28,7 +30,9 @@ module ZMachine
       client_socket = socket.accept
       return unless client_socket
       client_socket.configure_blocking(false)
-      TCPChannel.new(client_socket, @selector)
+      channel = TCPChannel.new(@selector)
+      channel.socket = client_socket
+      channel
     end
 
     def connect(address, port)
@@ -54,6 +58,10 @@ module ZMachine
       end
     end
 
+    def close_connection(flush = true)
+      @reactor.unbind_channel(self) if schedule_close(flush)
+    end
+
     def close
       if @channel_key
         @channel_key.cancel
@@ -84,7 +92,6 @@ module ZMachine
       until @outbound_queue.empty?
         buffer = @outbound_queue.first
         @socket.write(buffer) if buffer.remaining > 0
-
         # 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.
@@ -145,12 +152,17 @@ module ZMachine
       end
     end
 
+    # these two are a bit misleading .. only used for the zmq channel
     def has_more?
       false
     end
 
+    def can_send?
+      false
+    end
+
     def current_events
-      if @socket.respond_to?(:accept)
+      if @socket.is_a?(ServerSocketChannel)
         return SelectionKey::OP_ACCEPT
       end
 

data/lib/zmachine/zmq_channel.rb

@@ -4,16 +4,79 @@ java_import org.zeromq.ZMQException
 
 require 'zmachine/channel'
 
+class ZMsg
+  # for performance reason we alias the method here (otherwise it uses reflections all the time!)
+  java_alias :post, :send, [org.zeromq.ZMQ::Socket, Java::boolean]
+end
+
+# this needs to be moved to a seperate file
+class ZMQ
+  class Socket
+     def self.create_socket_with_opts(type, opts = {})
+      socket = ZMachine.context.create_socket(type)
+      socket.setLinger(opts[:linger]) if opts[:linger]
+      socket.setSndHWM(opts[:sndhwm]) if opts[:sndhwm]
+      socket.setRcvHWM(opts[:rcvhwm]) if opts[:rcvhwm]
+      socket.set_router_mandatory(true) if type == ZMQ::ROUTER
+      socket.connect(opts[:connect]) if opts[:connect]
+      socket.bind(opts[:bind]) if opts[:bind]
+      socket
+    end
+
+    def self.pair(opts = {})
+      create_socket_with_opts(ZMQ::PAIR, opts)
+    end
+    def self.router(opts = {})
+      create_socket_with_opts(ZMQ::ROUTER, opts)
+    end
+    def self.pull(opts = {})
+      create_socket_with_opts(ZMQ::PULL, opts)
+    end
+    def self.push(opts = {})
+      create_socket_with_opts(ZMQ::PUSH, opts)
+    end
+    def self.dealer(opts = {})
+      create_socket_with_opts(ZMQ::DEALER, opts)
+    end
+    def self.pub(opts = {})
+      create_socket_with_opts(ZMQ::PUB, opts)
+    end
+
+    def send2(a,b)
+      sent =  send a, ZMQ::SNDMORE | ZMQ::DONTWAIT
+      sent &= send b, ZMQ::DONTWAIT
+      sent
+    end
+
+    def send3(a,b,c)
+      sent =  send a, ZMQ::SNDMORE | ZMQ::DONTWAIT
+      sent &= send b, ZMQ::SNDMORE | ZMQ::DONTWAIT
+      sent &= send c, ZMQ::DONTWAIT
+      sent
+    end
+  end
+end
+
 module ZMachine
   class ZMQChannel < Channel
 
     attr_reader :port
+    attr_reader :socket
 
     def initialize(type, selector)
       super(selector)
-      @socket = ZMachine.context.create_socket(type)
-      @socket.linger = 0
-      @socket.set_router_mandatory(true) if type == ZMQ::ROUTER
+      @socket = ZMQChannel.create_socket_with_opts type, linger: 0
+    end
+
+    def self.create_socket_with_opts(type, opts = {})
+      socket = ZMachine.context.create_socket(type)
+      socket.setLinger(opts[:linger]) if opts[:linger]
+      socket.setSndHWM(opts[:sndhwm]) if opts[:sndhwm]
+      socket.setRcvHWM(opts[:rcvhwm]) if opts[:rcvhwm]
+      socket.set_router_mandatory(true) if type == ZMQ::ROUTER
+      socket.connect(opts[:connect]) if opts[:connect]
+      socket.bind(opts[:bind]) if opts[:bind]
+      socket
     end
 
     def register
@@ -45,10 +108,18 @@ module ZMachine
       @outbound_queue << data unless send_msg(data)
     end
 
+    def send2(a,b)
+      @socket.send2 a,b
+    end
+
+    def send3(a,b,c)
+      @socket.send3 a,b,c
+    end
+
     def send_msg(msg)
-      msg.java_send(:send, [org.zeromq.ZMQ::Socket], @socket)
+      msg.post(@socket, true)
       return true
-    rescue ZMQException
+    rescue ZMQException => e
       return false
     end
 

data/lib/zmachine.rb

@@ -17,6 +17,10 @@ module ZMachine
     attr_accessor :debug
   end
 
+  def self.clear_current_reactor
+    Thread.current[:reactor] = nil
+  end
+
   def self.reactor
     Thread.current[:reactor] ||= Reactor.new
   end
@@ -43,7 +47,7 @@ module ZMachine
   end
 
   def self._not_implemented
-    raise RuntimeError.new("API call not implemented!")
+    raise RuntimeError.new("API call not implemented! #{caller[0]}")
   end
 
   def self.add_periodic_timer(*args, &block)
@@ -112,6 +116,10 @@ module ZMachine
     _not_implemented
   end
 
+  def self.stop
+    Reactor.terminate_all_reactors
+  end
+
   def self.run_block(&block)
     pr = proc {
       block.call

data/spec/hashed_wheel_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'lib/zmachine/hashed_wheel'
+
+describe ZMachine::HashedWheelTimeout do
+  it 'calculates the stop index correctly'
+  it 'calculates remaining rounds correctly'
+  it 'can be cancelled'
+  it 'supports an action'
+end
+
+describe ZMachine::HashedWheel do
+  let(:wheel) { ZMachine::HashedWheel.new(16, 100) }
+
+  it 'returns a timeout on add' do
+    expect(wheel.add(0)).to be_instance_of(ZMachine::HashedWheelTimeout)
+  end
+
+  it 'adds timeouts to the correct slot' do
+    wheel.add 0
+    wheel.add 90
+    wheel.add 110
+    wheel.add 1000
+    wheel.add 1600
+    wheel.add 3200
+    expect(wheel.slots[0].length).to eq(4)
+    expect(wheel.slots[1].length).to eq(1)
+    expect(wheel.slots[10].length).to eq(1)
+  end
+
+  it 'times out same slot timeouts correctly' do
+    now = wheel.reset
+    wheel.add 10
+    wheel.add 50
+    timedout = wheel.advance(now + 30 * 1_000_000)
+    expect(timedout.length).to eq(1)
+  end
+
+  it 'calculates the timeouted set correctly' do
+    now = wheel.reset
+    wheel.add 10
+    wheel.add 40
+    wheel.add 1900
+    wheel.add 3300
+    wheel.add 4000
+    timedout = wheel.advance( now + 3900 * 1_000_000)
+    expect(timedout).to be
+    expect(timedout.length).to eq(4)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/zmachine.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "zmachine"
-  spec.version       = "0.1.1"
-  spec.authors       = ["madvertise Mobile Advertising GmbH"]
-  spec.email         = ["tech@madvertise.com"]
-  spec.description   = %q{pure JRuby multi-threaded EventMachine compatible event loop}
-  spec.summary       = %q{pure JRuby multi-threaded EventMachine compatible event loop}
+  spec.version       = "0.1.3"
+  spec.authors       = ["LiquidM, Inc."]
+  spec.email         = ["tech@liquidm.com"]
+  spec.description   = %q{pure JRuby multi-threaded mostly EventMachine compatible event loop}
+  spec.summary       = %q{pure JRuby multi-threaded mostly EventMachine compatible event loop}
   spec.homepage      = "https://github.com/madvertise/zmachine"
   spec.license       = "MIT"
 
@@ -17,4 +17,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

metadata

@@ -1,51 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: zmachine
 version: !ruby/object:Gem::Version
-  version: 0.1.1
-  prerelease:
+  version: 0.1.3
 platform: ruby
 authors:
-- madvertise Mobile Advertising GmbH
-autorequire:
+- LiquidM, Inc.
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-28 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-    none: false
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
   type: :development
-description: pure JRuby multi-threaded EventMachine compatible event loop
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: pure JRuby multi-threaded mostly EventMachine compatible event loop
 email:
-- tech@madvertise.com
+- tech@liquidm.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -62,36 +71,40 @@ files:
 - lib/zmachine/channel.rb
 - lib/zmachine/connection.rb
 - lib/zmachine/deferrable.rb
+- lib/zmachine/hashed_wheel.rb
 - lib/zmachine/jeromq-0.3.0-SNAPSHOT.jar
 - lib/zmachine/reactor.rb
 - lib/zmachine/tcp_channel.rb
 - lib/zmachine/timers.rb
 - lib/zmachine/zmq_channel.rb
+- spec/hashed_wheel_spec.rb
+- spec/spec_helper.rb
 - zmachine.gemspec
 homepage: https://github.com/madvertise/zmachine
 licenses:
 - MIT
-post_install_message:
+metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
-rubyforge_project:
-rubygems_version: 1.8.24
-signing_key:
-specification_version: 3
-summary: pure JRuby multi-threaded EventMachine compatible event loop
-test_files: []
-has_rdoc:
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: pure JRuby multi-threaded mostly EventMachine compatible event loop
+test_files:
+- spec/hashed_wheel_spec.rb
+- spec/spec_helper.rb
+has_rdoc: