zmachine 0.1.0

data/lib/zmachine/reactor.rb

@@ -0,0 +1,337 @@
+java_import java.io.FileDescriptor
+java_import java.io.IOException
+java_import java.net.InetSocketAddress
+java_import java.nio.ByteBuffer
+java_import java.nio.channels.ClosedChannelException
+java_import java.nio.channels.SelectionKey
+java_import java.nio.channels.Selector
+java_import java.nio.channels.ServerSocketChannel
+java_import java.nio.channels.SocketChannel
+java_import java.util.TreeMap
+java_import java.util.concurrent.atomic.AtomicBoolean
+java_import java.util.concurrent.ConcurrentLinkedQueue
+
+require 'zmachine/jeromq-0.3.0-SNAPSHOT.jar'
+java_import org.zeromq.ZContext
+
+require 'zmachine/acceptor'
+require 'zmachine/tcp_channel'
+require 'zmachine/zmq_channel'
+
+module ZMachine
+  class Reactor
+
+    def initialize
+      @timers = TreeMap.new
+      @timer_callbacks = {}
+      @channels = []
+      @new_channels = []
+      @unbound_channels = []
+      @next_signature = 0
+      @shutdown_hooks = []
+      @next_tick_queue = ConcurrentLinkedQueue.new
+      @running = false
+
+      # don't use a direct buffer. Ruby doesn't seem to like them.
+      @read_buffer = ByteBuffer.allocate(32*1024)
+    end
+
+    def add_shutdown_hook(&block)
+      @shutdown_hooks << block
+    end
+
+    def add_timer(*args, &block)
+      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
+
+      if @timers.contains_key(deadline)
+        @timers.get(deadline) << signature
+      else
+        @timers.put(deadline, [signature])
+      end
+
+      @timer_callbacks[signature] = callback
+      signature
+    end
+
+    def cancel_timer(timer_or_sig)
+      if timer_or_sig.respond_to?(:cancel)
+        timer_or_sig.cancel
+      else
+        @timer_callbacks[timer_or_sig] = false if @timer_callbacks.has_key?(timer_or_sig)
+      end
+    end
+
+    def connect(server, port_or_type=nil, handler=nil, *args, &block)
+      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
+    end
+
+    def connection_count
+      @channels.size
+    end
+
+    def error_handler(callback = nil, &block)
+      @error_handler = callback || block
+    end
+
+    def next_tick(callback=nil, &block)
+      @next_tick_queue << (callback || block)
+      signal_loopbreak if running?
+    end
+
+    def run(callback=nil, shutdown_hook=nil, &block)
+      @callback = callback || block
+
+      add_shutdown_hook(shutdown_hook) if shutdown_hook
+
+      begin
+        @running = true
+
+        add_timer(0, @callback) if @callback
+
+        @selector = Selector.open
+        @run_reactor = true
+
+        while @run_reactor
+          run_deferred_callbacks
+          break unless @run_reactor
+          run_timers
+          break unless @run_reactor
+          remove_unbound_channels
+          check_io
+          add_new_channels
+          process_io
+        end
+      ensure
+        @selector.close rescue nil
+        @selector = nil
+        @unbound_channels += @channels
+        remove_unbound_channels
+        @shutdown_hooks.pop.call until @shutdown_hooks.empty?
+        @next_tick_queue = ConcurrentLinkedQueue.new
+        @running = false
+        ZMachine.context.destroy
+      end
+    end
+
+    def reactor_running?
+      @running || false
+    end
+
+    def start_server(server, port_or_type=nil, handler=nil, *args, &block)
+      if server =~ %r{\w+://}
+        _bind_zmq(server, port_or_type, handler, *args, &block)
+      else
+        _bind_tcp(server, port_or_type, handler, *args, &block)
+      end
+    end
+
+    def stop_event_loop
+      @run_reactor = false
+      signal_loopbreak
+    end
+
+    def stop_server(channel)
+      channel.close
+    end
+
+    private
+
+    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)
+    end
+
+    def _bind_zmq(address, type, handler, *args, &block)
+      klass = _klass_from_handler(Connection, handler)
+      channel = ZMQChannel.new(type, @selector)
+      channel.bind(address)
+      add_channel(channel, klass, *args, &block)
+    end
+
+    def _connect_tcp(address, port, handler=nil, *args, &block)
+      klass = _klass_from_handler(Connection, handler)
+      channel = TCPChannel.new(@selector)
+      channel.connect(address, port)
+      channel.connect_pending = true
+      add_channel(channel, klass, *args, &block)
+    end
+
+    def _connect_zmq(address, type, handler=nil, *args, &block)
+      klass = _klass_from_handler(Connection, handler)
+      channel = ZMQChannel.new(type, @selector)
+      add_channel(channel, klass, *args, &block)
+      channel.connect(address)
+      channel.handler.connection_completed
+      channel
+    end
+
+    def check_io
+      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 = -1 if timeout <= 0
+      else
+        timeout = 0
+      end
+
+      if @channels.any?(&:has_more?)
+        timeout = -1
+      end
+
+      if timeout == -1
+        @selector.select_now
+      else
+        @selector.select(timeout)
+      end
+    end
+
+    def process_io
+      it = @selector.selected_keys.iterator
+
+      while it.has_next
+        selected_key = it.next
+        it.remove
+
+        if selected_key.connectable?
+          is_connectable(selected_key.attachment)
+        elsif selected_key.acceptable?
+          is_acceptable(selected_key.attachment)
+        else
+          is_writable(selected_key.attachment) if selected_key.writable?
+          is_readable(selected_key.attachment) if selected_key.readable?
+        end
+      end
+
+      @channels.each do |channel|
+        is_readable(channel) if channel.has_more?
+        is_writable(channel) if channel.can_send?
+      end
+    end
+
+    def is_acceptable(channel)
+      client_channel = channel.accept(next_signature)
+      acceptor = channel.handler
+      add_channel(client_channel, acceptor.klass, *acceptor.args, &acceptor.callback)
+    rescue IOException
+      channel.close
+    end
+
+    def is_readable(channel)
+      data = channel.read_inbound_data(@read_buffer)
+      channel.handler.receive_data(data) if data
+    rescue IOException
+      @unbound_channels << channel
+    end
+
+    def is_writable(channel)
+      @unbound_channels << channel unless channel.write_outbound_data
+    rescue IOException
+      @unbound_channels << channel
+    end
+
+    def is_connectable(channel)
+      channel.finish_connecting
+      channel.handler.connection_completed
+    rescue IOException
+      @unbound_channels << channel
+    end
+
+    def add_channel(channel, klass, *args, &block)
+      channel.handler = klass.new(channel, *args)
+      @new_channels << channel
+      block.call(channel.handler) if block
+      channel
+    end
+
+    def add_new_channels
+      @new_channels.each do |channel|
+        begin
+          channel.register
+          @channels << channel
+        rescue ClosedChannelException
+          @unbound_channels << channel
+        end
+      end
+      @new_channels.clear
+    end
+
+    def remove_unbound_channels
+      @unbound_channels.each do |channel|
+        channel.handler.unbind if channel.handler
+        channel.close
+      end
+      @unbound_channels.clear
+    end
+
+    def run_deferred_callbacks
+      # max is current size
+      size = @next_tick_queue.size
+      while size > 0 && callback = @next_tick_queue.poll
+        begin
+          size -= 1
+          callback.call
+        ensure
+          ZMachine.next_tick {} if $!
+        end
+      end
+    end
+
+    def run_timers
+      now = java.util.Date.new.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)
+          return if callback == false # callback cancelled
+          callback or raise UnknownTimerFired, "callback data: #{signature}"
+          callback.call
+        end
+      end
+    end
+
+    def signal_loopbreak
+      @selector.wakeup if @selector
+    end
+
+    def next_signature
+      @next_signature += 1
+    end
+
+    def _klass_from_handler(klass = Connection, handler = nil)
+      if handler and handler.is_a?(Class)
+        handler
+      elsif handler
+        _handler_from_klass(klass, handler)
+      else
+        klass
+      end
+    end
+
+    def _handler_from_module(klass, handler)
+      handler::CONNECTION_CLASS
+    rescue NameError
+      handler::const_set(:CONNECTION_CLASS, Class.new(klass) { include handler })
+    end
+
+  end
+end

data/lib/zmachine/tcp_channel.rb

@@ -0,0 +1,169 @@
+java_import java.nio.channels.ServerSocketChannel
+
+require 'zmachine/channel'
+
+module ZMachine
+  class TCPChannel < Channel
+
+    attr_reader :connect_pending
+
+    def initialize(selector)
+      super(selector)
+      @close_scheduled = false
+      @connect_pending = false
+    end
+
+    def register
+      @channel_key ||= @socket.register(@selector, current_events, self)
+    end
+
+    def bind(address, port)
+      address = InetSocketAddress.new(address, port)
+      @socket = ServerSocketChannel.open
+      @socket.configure_blocking(false)
+      @socket.bind(address)
+    end
+
+    def accept
+      client_socket = socket.accept
+      return unless client_socket
+      client_socket.configure_blocking(false)
+      TCPChannel.new(client_socket, @selector)
+    end
+
+    def connect(address, port)
+      address = InetSocketAddress.new(address, port)
+      @socket = SocketChannel.open
+      @socket.configure_blocking(false)
+
+      if socket.connect(address)
+        # Connection returned immediately. Can happen with localhost
+        # connections.
+        # WARNING, this code is untested due to lack of available test
+        # conditions.  Ought to be be able to come here from a localhost
+        # connection, but that doesn't happen on Linux. (Maybe on FreeBSD?)
+        # The reason for not handling this until we can test it is that we
+        # really need to return from this function WITHOUT triggering any EM
+        # events.  That's because until the user code has seen the signature
+        # we generated here, it won't be able to properly dispatch them. The
+        # C++ EM deals with this by setting pending mode as a flag in ALL
+        # eventable descriptors and making the descriptor select for
+        # writable. Then, it can send UNBOUND and CONNECTION_COMPLETED on the
+        # next pass through the loop, because writable will fire.
+        raise RuntimeError.new("immediate-connect unimplemented")
+      end
+    end
+
+    def close
+      if @channel_key
+        @channel_key.cancel
+        @channel_key = nil
+      end
+
+      @socket.close rescue nil
+    end
+
+    def send_data(data)
+      return if @close_scheduled
+      buffer = ByteBuffer.wrap(data.to_java_bytes)
+      if buffer.remaining() > 0
+        @outbound_queue << buffer
+        update_events
+      end
+    end
+
+    def read_inbound_data(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])
+    end
+
+    def write_outbound_data
+      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.
+        if buffer.remaining == 0
+          @outbound_queue.shift
+        else
+          break
+        end
+      end
+
+      if @outbound_queue.empty? && !@close_scheduled
+        update_events
+      end
+
+      return (@close_scheduled && @outbound_queue.empty?) ? false : true
+    end
+
+    def finish_connecting
+      @socket.finish_connect
+      @connect_pending = false
+      update_events
+      return true
+    end
+
+    def schedule_close(after_writing)
+      @outbound_queue.clear unless after_writing
+
+      if @outbound_queue.empty?
+        return true
+      else
+        update_events
+        @close_scheduled = true
+        return false
+      end
+    end
+
+    # TODO: fix these
+    def peer_name
+      sock = @socket.socket
+      [sock.port, sock.inet_address.host_address]
+    end
+
+    def sock_name
+      sock = @socket.socket
+      [sock.local_port, sock.local_address.host_address]
+    end
+
+    def connect_pending=(value)
+      @connect_pending = value
+      update_events
+    end
+
+    def update_events
+      return unless @channel_key
+      events = current_events
+      if @channel_key.interest_ops != events
+        @channel_key.interest_ops(events)
+      end
+    end
+
+    def has_more?
+      false
+    end
+
+    def current_events
+      if @socket.respond_to?(:accept)
+        return SelectionKey::OP_ACCEPT
+      end
+
+      events = 0
+
+      if @connect_pending
+        events |= SelectionKey::OP_CONNECT
+      else
+        events |= SelectionKey::OP_READ
+        events |= SelectionKey::OP_WRITE unless @outbound_queue.empty?
+      end
+
+      return events
+    end
+  end
+end

data/lib/zmachine/timers.rb

@@ -0,0 +1,61 @@
+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
+
+  # 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)
+      schedule
+    end
+
+    # Cancel the periodic timer
+    def cancel
+      @cancelled = true
+    end
+
+    # Fire the timer every interval seconds
+    attr_accessor :interval
+
+    # @private
+    def schedule
+      ZMachine.add_timer(@interval, @work)
+    end
+
+    # @private
+    def fire
+      unless @cancelled
+        @code.call
+        schedule
+      end
+    end
+  end
+end

data/lib/zmachine/zmq_channel.rb

@@ -0,0 +1,101 @@
+java_import org.zeromq.ZMQ
+java_import org.zeromq.ZMsg
+java_import org.zeromq.ZMQException
+
+require 'zmachine/channel'
+
+module ZMachine
+  class ZMQChannel < Channel
+
+    attr_reader :port
+
+    def initialize(type, selector)
+      super(selector)
+      @socket = ZMachine.context.create_socket(type)
+      @socket.linger = 0
+      @socket.set_router_mandatory(true) if type == ZMQ::ROUTER
+    end
+
+    def register
+      @channel_key ||= @socket.fd.register(@selector, current_events, self)
+    end
+
+    def bind(address)
+      @port = @socket.bind(address)
+    end
+
+    def connect(address)
+      @socket.connect(address) if address
+    end
+
+    def identity=(value)
+      @socket.identity = value.to_java_bytes
+    end
+
+    def close
+      if @channel_key
+        @channel_key.cancel
+        @channel_key = nil
+      end
+
+      @socket.close
+    end
+
+    def send_data(data)
+      @outbound_queue << data unless send_msg(data)
+    end
+
+    def send_msg(msg)
+      msg.java_send(:send, [org.zeromq.ZMQ::Socket], @socket)
+      return true
+    rescue ZMQException
+      return false
+    end
+
+    def read_inbound_data(buffer)
+      return unless has_more?
+      ZMsg.recv_msg(@socket)
+    end
+
+    def write_outbound_data
+      until @outbound_queue.empty?
+        data = @outbound_queue.first
+        if send_msg(data)
+          @outbound_queue.shift
+        else
+          break
+        end
+      end
+
+      return true
+    end
+
+    def has_more?
+      @socket.events & ZMQ::Poller::POLLIN == ZMQ::Poller::POLLIN
+    end
+
+    def can_send?
+      @socket.events & ZMQ::Poller::POLLOUT == ZMQ::Poller::POLLOUT
+    end
+
+    def schedule_close(after_writing)
+      true
+    end
+
+    # TODO: fix me
+    def peer_name
+      sock = @socket.socket
+      [sock.port, sock.inet_address.host_address]
+    end
+
+    def sock_name
+      sock = @socket.socket
+      [sock.local_port, sock.local_address.host_address]
+    end
+
+    def current_events
+      SelectionKey::OP_READ
+    end
+
+  end
+end