zmachine 0.3.2 → 0.4.0

data/java/com/liquidm/zmachine/HashedWheel.java

@@ -0,0 +1,120 @@
+package com.liquidm.zmachine;
+
+import java.lang.System;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.Callable;
+
+public class HashedWheel
+{
+	private class Timeout
+	{
+		long deadline;
+		Object callback;
+		boolean canceled;
+
+		public Timeout(long deadline, Object callback)
+		{
+			this.deadline = deadline;
+			this.callback = callback;
+			this.canceled = false;
+		}
+
+		public Object getCallback()
+		{
+			return this.callback;
+		}
+
+		public void cancel()
+		{
+			this.canceled = true;
+		}
+
+		public boolean isCanceled()
+		{
+			return this.canceled;
+		}
+	}
+
+	int number_of_slots;
+	long tick_length;
+	Object[] slots;
+	int current_tick;
+	long last;
+
+	public HashedWheel(int number_of_slots, long tick_length)
+	{
+		this.number_of_slots = number_of_slots;
+		this.tick_length = tick_length * 1000000; // ms to ns
+		reset();
+	}
+
+	@SuppressWarnings("unchecked")
+	public Object[] getSlots()
+	{
+		return this.slots;
+	}
+
+	public Timeout add(int timeout)
+	{
+		return add(timeout, null);
+	}
+
+	@SuppressWarnings("unchecked")
+	public Timeout add(long timeout, Object callback)
+	{
+		timeout = timeout * 1000000; // ms to ns
+		long ticks = timeout / this.tick_length;
+		int slot = (int)((this.current_tick + ticks) % this.number_of_slots);
+		long deadline = System.nanoTime() + timeout;
+		Timeout hwt = new Timeout(deadline, callback);
+		ArrayList<Timeout> list = (ArrayList<Timeout>) this.slots[slot];
+		list.add(hwt);
+		return hwt;
+	}
+
+	public long reset()
+	{
+		return reset(System.nanoTime());
+	}
+
+	public long reset(long last)
+	{
+		this.slots = new Object[this.number_of_slots];
+		for (int i = 0; i < this.number_of_slots; i++) {
+			this.slots[i] = new ArrayList<Timeout>();
+		}
+		this.current_tick = 0;
+		this.last = last;
+		return last;
+	}
+
+	public ArrayList<Timeout> advance()
+	{
+		return advance(System.nanoTime());
+	}
+
+	@SuppressWarnings("unchecked")
+	public ArrayList<Timeout> advance(long now)
+	{
+		long passed_ticks = (now - this.last) / this.tick_length;
+		ArrayList<Timeout> result = new ArrayList<Timeout>();
+		do {
+			this.current_tick = this.current_tick % this.number_of_slots;
+			Iterator<Timeout> it = ((ArrayList<Timeout>)this.slots[this.current_tick]).iterator();
+			while (it.hasNext()) {
+				Timeout timeout = it.next();
+				if (timeout.deadline < now) {
+					if (!timeout.isCanceled()) {
+						result.add(timeout);
+					}
+					it.remove();
+				}
+			}
+			this.current_tick += 1;
+			passed_ticks -= 1;
+		} while (passed_ticks > 0);
+		this.last = now;
+		return result;
+	}
+}

data/lib/zmachine.rb

@@ -46,8 +46,8 @@ module ZMachine
     timer_or_sig.cancel # we do not support signatures
   end
 
-  def self.close_connection(connection, reason = nil)
-    reactor.close_connection(connection, reason)
+  def self.close_connection(connection, after_writing = false, reason = nil)
+    reactor.close_connection(connection, after_writing, reason)
   end
 
   def self.connect(server, port_or_type=nil, handler=nil, *args, &block)
@@ -59,11 +59,11 @@ module ZMachine
   end
 
   def self.heartbeat_interval
-    reactor.heartbeat_interval
+    @heartbeat_interval
   end
 
   def self.heartbeat_interval=(time)
-    reactor.heartbeat_interval = time
+    @heartbeat_interval = time
   end
 
   def self.next_tick(callback=nil, &block)

data/lib/zmachine/channel.rb

@@ -8,7 +8,6 @@ module ZMachine
     attr_accessor :raw
 
     def initialize
-      @inbound_buffer = ByteBuffer.allocate(1024 * 1024)
       @outbound_queue = ConcurrentLinkedQueue.new
       @raw = false
     end
@@ -30,7 +29,7 @@ module ZMachine
     # write_outbound_data
 
     def can_send?
-      !@outbound_queue.empty?
+      connected? && !@outbound_queue.empty?
     end
 
     def send_data(data)
@@ -55,25 +54,13 @@ module ZMachine
         break if buffer.has_remaining
         @outbound_queue.poll
       end
-      maybe_close_with_callback
     end
 
-    def close(after_writing = false, &block)
+    def close
       return true if closed?
-      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self, after_writing: after_writing, caller: caller[0].inspect) if ZMachine.debug
-      @close_scheduled = true
-      @closed_callback = block if block
-      @outbound_queue.clear unless after_writing
-      maybe_close_with_callback
-    end
-
-    def maybe_close_with_callback
-      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self, can_send: can_send?) if ZMachine.debug
-      return false if can_send?
-      return true unless @close_scheduled
+      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self, caller: caller[0].inspect) if ZMachine.debug
+      @outbound_queue.clear
       close!
-      @closed_callback.call if @closed_callback
-      return true
     end
 
   end

data/lib/zmachine/connection.rb

@@ -10,6 +10,7 @@ module ZMachine
     extend Forwardable
 
     attr_accessor :channel
+    attr_reader :timer
 
     def self.new(*args)
       allocate.instance_eval do
@@ -61,14 +62,13 @@ module ZMachine
     # EventMachine Connection API
 
     def_delegator :@channel, :bound?
+    def_delegator :@channel, :can_send?
     def_delegator :@channel, :closed?
     def_delegator :@channel, :connected?
     def_delegator :@channel, :connection_pending?
 
     def close_connection(after_writing = false)
-      @channel.close(after_writing) do
-        ZMachine.close_connection(self)
-      end
+      ZMachine.close_connection(self, after_writing)
     end
 
     alias :close :close_connection
@@ -79,6 +79,11 @@ module ZMachine
 
     alias :close_after_writing close_connection_after_writing
 
+    def close!
+      @timer.cancel if @timer
+      @channel.close!
+    end
+
     def comm_inactivity_timeout
       @inactivity_timeout
     end
@@ -213,8 +218,7 @@ module ZMachine
         readable! if @channel_key.readable?
       end
     rescue Java::JavaNioChannels::CancelledKeyException
-      # channel may have been closed by write handler. ignore exception and
-      # wait for cleanup
+      ZMachine.close_connection(self)
     end
 
     def mark_active!
@@ -225,9 +229,9 @@ module ZMachine
     def renew_timer
       @timer.cancel if @timer
       if connection_pending? && @connect_timeout
-        @timer = ZMachine.add_timer(@connect_timeout) { ZMachine.close_connection(self, Errno::ETIMEDOUT) }
+        @timer = ZMachine.add_timer(@connect_timeout) { ZMachine.close_connection(self, true, Errno::ETIMEDOUT) }
       elsif @inactivity_timeout
-        @timer = ZMachine.add_timer(@inactivity_timeout) { ZMachine.close_connection(self, Errno::ETIMEDOUT) }
+        @timer = ZMachine.add_timer(@inactivity_timeout) { ZMachine.close_connection(self, true, Errno::ETIMEDOUT) }
       end
     end
 

data/lib/zmachine/connection_manager.rb

@@ -15,7 +15,7 @@ module ZMachine
       @connections = Set.new
       @zmq_connections = Set.new
       @new_connections = Set.new
-      @unbound_connections = Set.new
+      @closing_connections = []
     end
 
     def idle?
@@ -25,7 +25,7 @@ module ZMachine
 
     def shutdown
       ZMachine.logger.debug("zmachine:connection_manager:#{__method__}") if ZMachine.debug
-      @unbound_connections += @connections
+      @closing_connections += @connections.to_a
       cleanup
     end
 
@@ -73,12 +73,12 @@ module ZMachine
       new_connection = connection.process_events
       @new_connections << new_connection if new_connection
     rescue IOException => e
-      close_connection(connection, e)
+      close_connection(connection, false, e)
     end
 
-    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]
+    def close_connection(connection, after_writing = false, reason = nil)
+      ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", connection: connection, after_writing: after_writing, reason: reason.inspect) if ZMachine.debug
+      @closing_connections << [connection, after_writing, reason]
     end
 
     def add_new_connections
@@ -92,7 +92,7 @@ module ZMachine
             connection.connection_completed
           end
         rescue ClosedChannelException => e
-          @unbound_connections << [connection, e]
+          @closing_connections << [connection, false, e]
         end
       end
       @new_connections.clear
@@ -103,25 +103,34 @@ module ZMachine
     end
 
     def cleanup
-      return if @unbound_connections.empty?
+      return if @closing_connections.empty?
       ZMachine.logger.debug("zmachine:connection_manager:#{__method__}") if ZMachine.debug
-      @unbound_connections.each do |connection|
-        reason = nil
-        connection, reason = *connection if connection.is_a?(Array)
-        begin
-          @connections.delete(connection)
-          @zmq_connections.delete(connection)
-          if connection.method(:unbind).arity != 0
-            connection.unbind(reason)
-          else
-            connection.unbind
-          end
-          connection.channel.close!
-        rescue Exception => e
-          ZMachine.logger.exception(e, "failed to unbind connection") if ZMachine.debug
-        end
+      closing_connections = @closing_connections
+      @closing_connections = []
+      closing_connections.each do |connection|
+        unbind_connection(connection)
+      end
+    end
+
+    def unbind_connection(connection)
+      after_writing = false
+      reason = nil
+      connection, after_writing, reason = *connection if connection.is_a?(Array)
+      if connection.method(:unbind).arity != 0
+        connection.unbind(reason)
+      else
+        connection.unbind
+      end
+      ZMachine.logger.debug("zmachine:connection_manager:#{__method__}", connection: connection, after_writing: after_writing, can_send: connection.can_send?) if ZMachine.debug
+      if after_writing && connection.can_send?
+        ZMachine.close_connection(connection, true)
+      else
+        connection.close!
+        @connections.delete(connection)
+        @zmq_connections.delete(connection)
       end
-      @unbound_connections.clear
+    rescue Exception => e
+      ZMachine.logger.exception(e, "failed to unbind connection") if ZMachine.debug
     end
 
     private

data/lib/zmachine/hashed_wheel.rb

@@ -1,70 +1,5 @@
-java_import java.lang.System
+$CLASSPATH << File.expand_path("../../../java", __FILE__)
 
 module ZMachine
-
-  class HashedWheelTimeout
-    attr_reader :deadline
-    attr_reader :callback
-
-    def initialize(deadline, &block)
-      @deadline = deadline
-      @callback = block
-      @canceled = false
-    end
-
-    def cancel
-      @canceled = true
-    end
-
-    def canceled?
-      @canceled
-    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_000
-      @last = start_time
-      @current_tick = 0
-    end
-
-    def add(timeout, &block)
-      timeout *= 1_000_000_000 # s to ns
-      ticks = timeout / @tick_length
-      slot = (@current_tick + ticks) % @slots.length
-      deadline = System.nano_time + timeout
-      @slots[slot] << hwt = HashedWheelTimeout.new(deadline, &block)
-      hwt
-    end
-
-    def reset(time = nil)
-      @slots = Array.new(@slots.length) { [] }
-      @current_tick = 0
-      @last = time || System.nano_time
-    end
-
-    # returns all timeouts
-    def advance(now = nil)
-      now ||= System.nano_time
-      passed_ticks = (now - @last) / @tick_length
-      result = []
-      begin
-        @current_tick %= @slots.length
-        @slots[@current_tick].delete_if do |timeout|
-          result << timeout if timeout.deadline < now
-        end
-        @current_tick += 1
-        passed_ticks -= 1
-      end while passed_ticks > 0
-      @last = now
-      result.reject do |timeout|
-        timeout.canceled?
-      end
-    end
-
-  end
+  HashedWheel = Java::ComLiquidmZmachine::HashedWheel
 end

data/lib/zmachine/reactor.rb

@@ -35,12 +35,12 @@ module ZMachine
     end
 
     def initialize
-      # a 10 ms tick wheel with 512 slots => ~5s for a round
-      @heartbeat_interval = 0.5 # coarse grained by default
+      @heartbeat_interval = ZMachine.heartbeat_interval || 0.5 # coarse grained by default
       @next_tick_queue = ConcurrentLinkedQueue.new
       @running = false
       @shutdown_hooks = []
-      @wheel = HashedWheel.new(512, 0.01)
+      # a 10 ms tick wheel with 512 slots => ~5s for a round
+      @wheel = HashedWheel.new(512, 10)
     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, &callback)
+      @wheel.add((interval * 1000).to_i, &callback)
     end
 
     def bind(server, port_or_type=nil, handler=nil, *args, &block)
@@ -62,9 +62,9 @@ module ZMachine
       @connection_manager.bind(server, port_or_type, handler, *args, &block)
     end
 
-    def close_connection(connection, reason = nil)
+    def close_connection(connection, after_writing = false, reason = nil)
       return true unless @connection_manager
-      @connection_manager.close_connection(connection, reason)
+      @connection_manager.close_connection(connection, after_writing, reason)
     end
 
     def connect(server, port_or_type=nil, handler=nil, *args, &block)
@@ -94,7 +94,6 @@ module ZMachine
     def reconnect(server, port_or_type, handler)
       return handler if handler && handler.channel.is_a?(ZMQChannel)
       ZMachine.logger.debug("zmachine:reactor:#{__method__}", server: server, port_or_type: port_or_type) if ZMachine.debug
-      return handler if handler.connected?
       connect(server, port_or_type, handler)
     end