zmachine 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1057ef6c0aa36f93cf288ce0f90f6d231888c7b8
-  data.tar.gz: bf0799c9baf044fdd371bdbf7d1b71e325cd419d
+  metadata.gz: ae108dc1b3349d10953fdbf480eb04399e955210
+  data.tar.gz: 0c21b76fea1dac030296db4af61132a4378f5c6c
 SHA512:
-  metadata.gz: 01187e9649e5f6d48f03cb4ac0a8fd1766e1be10cba3fbfbaefdf49cefce174157c5fb155acd60effb79bc8e8a02a9c20ec3f5ec6779ca44dac90aa5294fddf4
-  data.tar.gz: 8ea1eb56b13ce6b7786de2224859e6fdad142e14fe7602bf6a499e16a7853291dea5e504427f4e8a625b8ff5800a51dd76aa97bad52c0de908d82af89481bf40
+  metadata.gz: cf74518f087c16dbdc05982c3aae1beeea4e948995b83cdad5f77223cdcb0c6c90c1461df3c616ce5fa4713b337ed6f65736ece7c10874f3677239b38a6ee9b7
+  data.tar.gz: 1756c03d9be7a36ed549f8e954c74d8bf2614d7e9b1638b2bb9d343b4c4c566366aee682a05382a365754c72d630877db3242fa56ba5a9b76a2a9c85c8ffadc7

data/Gemfile

@@ -4,3 +4,5 @@ gemspec
 
 gem 'liquid-development'
 gem 'liquid-ext'
+gem 'ruby-debug'
+gem 'z-http-request', path: '../z-http-request'

data/README.md

@@ -4,6 +4,7 @@ ZMachine is a pure JRuby multi-threaded event loop based on java.nio.Selector
 and a hashed wheel timer implementation. ZMachine supports TCP and ZeroMQ
 sockets natively and exposes an EventMachine compatible API where possible.
 
+[![Gem Version](https://badge.fury.io/rb/zmachine.png)](http://badge.fury.io/rb/zmachine)
 [![Build Status](https://travis-ci.org/liquidm/zmachine.png)](https://travis-ci.org/liquidm/zmachine)
 [![Code Climate](https://codeclimate.com/github/liquidm/zmachine.png)](https://codeclimate.com/github/liquidm/zmachine)
 [![Dependency Status](https://gemnasium.com/liquidm/zmachine.png)](https://gemnasium.com/liquidm/zmachine)

data/lib/zmachine.rb

@@ -1,4 +1,4 @@
-require 'zmachine/jeromq-0.3.0-SNAPSHOT.jar'
+require 'zmachine/jeromq-0.3.2-SNAPSHOT.jar'
 java_import org.zeromq.ZContext
 
 require 'liquid/boot'
@@ -10,9 +10,6 @@ require 'zmachine/timers'
 
 module ZMachine
   class ConnectionError < RuntimeError; end
-  class ConnectionNotBound < RuntimeError; end
-  class UnknownTimerFired < RuntimeError; end
-  class Unsupported < RuntimeError; end
 
   class << self
     attr_accessor :logger
@@ -27,15 +24,10 @@ module ZMachine
     Thread.current[:reactor] ||= Reactor.new
   end
 
-  # TODO: move to ZMQChannel
   def self.context
     Thread.current[:context] ||= ZContext.new
   end
 
-  def self._not_implemented
-    raise RuntimeError.new("API call not implemented! #{caller[0]}")
-  end
-
   def self.add_periodic_timer(*args, &block)
     interval = args.shift
     callback = args.shift || block
@@ -50,66 +42,22 @@ module ZMachine
     reactor.add_timer(*args, &block)
   end
 
-  def self.attach(io, handler = nil, *args, &blk)
-    _not_implemented
-  end
-
-  def self.bind_connect(bind_addr, bind_port, server, port = nil, handler = nil, *args)
-    _not_implemented
-  end
-
-  def self.Callback(object = nil, method = nil, &blk)
-    _not_implemented
-  end
-
   def self.cancel_timer(timer_or_sig)
     timer_or_sig.cancel # we do not support signatures
   end
 
-  def self.close_connection(connection)
-    reactor.close_connection(connection)
+  def self.close_connection(connection, reason = nil)
+    reactor.close_connection(connection, reason)
   end
 
   def self.connect(server, port_or_type=nil, handler=nil, *args, &block)
     reactor.connect(server, port_or_type, handler, *args, &block)
   end
 
-  def self.connect_unix_domain(socketname, *args, &blk)
-    _not_implemented
-  end
-
   def self.connection_count
     reactor.connections.size
   end
 
-  def self.defer(op = nil, callback = nil, &blk)
-    _not_implemented
-  end
-
-  def self.defers_finished?
-    _not_implemented
-  end
-
-  def self.disable_proxy(from)
-    _not_implemented
-  end
-
-  def self.enable_proxy(from, to, bufsize = 0, length = 0)
-    _not_implemented
-  end
-
-  def self.error_handler(callback = nil, &block)
-    _not_implemented
-  end
-
-  def self.fork_reactor(&block)
-    _not_implemented
-  end
-
-  def self.get_max_timers
-    _not_implemented
-  end
-
   def self.heartbeat_interval
     reactor.heartbeat_interval
   end
@@ -122,22 +70,10 @@ module ZMachine
     reactor.next_tick(callback, &block)
   end
 
-  def self.open_datagram_socket(address, port, handler = nil, *args)
-    _not_implemented
-  end
-
-  def self.popen(cmd, handler = nil, *args)
-    _not_implemented
-  end
-
   def self.reactor_running?
     reactor.running?
   end
 
-  def self.reactor_thread?
-    _not_implemented
-  end
-
   def self.reconnect(server, port, handler)
     reactor.reconnect(server, port, handler)
   end
@@ -154,38 +90,10 @@ module ZMachine
     run(&pr)
   end
 
-  def self.schedule(*a, &b)
-    _not_implemented
-  end
-
-  def self.set_descriptor_table_size(n_descriptors = nil)
-    _not_implemented
-  end
-
-  def self.set_effective_user(username)
-    _not_implemented
-  end
-
-  def self.set_max_timers(ct)
-    _not_implemented
-  end
-
-  def self.set_quantum(mills)
-    _not_implemented
-  end
-
-  def self.spawn(&block)
-    _not_implemented
-  end
-
   def self.start_server(server, port_or_type=nil, handler=nil, *args, &block)
     reactor.bind(server, port_or_type, handler, *args, &block)
   end
 
-  def self.start_unix_domain_server(filename, *args, &block)
-    _not_implemented
-  end
-
   def self.stop_event_loop
     reactor.stop_event_loop
   end
@@ -198,26 +106,6 @@ module ZMachine
     Reactor.terminate_all_reactors
   end
 
-  def self.system(cmd, *args, &cb)
-    _not_implemented
-  end
-
-  def self.tick_loop(*a, &b)
-    _not_implemented
-  end
-
-  def self.watch(io, handler = nil, *args, &blk)
-    _not_implemented
-  end
-
-  def self.watch_file(filename, handler = nil, *args)
-    _not_implemented
-  end
-
-  def self.watch_process(pid, handler = nil, *args)
-    _not_implemented
-  end
-
 end
 
 if ENV['DEBUG']

data/lib/zmachine/acceptor.rb

@@ -4,7 +4,7 @@ module ZMachine
     attr_reader :args
     attr_reader :callback
 
-    def initialize(channel, klass, *args )
+    def initialize(channel, klass, *args)
       @klass, @args, @callback = klass, args[0...-1], args.last
       @channel = channel
     end

data/lib/zmachine/channel.rb

@@ -4,11 +4,12 @@ module ZMachine
   class Channel
 
     attr_accessor :socket
+    attr_accessor :raw
 
     def initialize
       @inbound_buffer = ByteBuffer.allocate(1024 * 1024)
       @outbound_queue = []
-      @close_scheduled = false
+      @raw = false
     end
 
     # methods that need to be implemented in sub classes:
@@ -31,14 +32,46 @@ module ZMachine
       !@outbound_queue.empty?
     end
 
-    def close(after_writing = false)
-      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self, after_writing: after_writing) if ZMachine.debug
+    def send_data(data)
+      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self) if ZMachine.debug
+      raise RuntimeError.new("send_data called after close") if @closed_callback
+      return unless data
+      buffer = ByteBuffer.wrap(data)
+      if buffer.has_remaining
+        @outbound_queue << buffer
+      end
+    end
+
+    def write_outbound_data
+      ZMachine.logger.debug("zmachine:channel:#{__method__}", channel: self, can_send: can_send?) if ZMachine.debug
+      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.
+        break if buffer.has_remaining
+        @outbound_queue.shift
+      end
+      maybe_close_with_callback
+    end
+
+    def close(after_writing = false, &block)
+      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 close_after_writing
-      close(true)
+    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
+      close!
+      @closed_callback.call if @closed_callback
+      return true
     end
 
   end

data/lib/zmachine/connection.rb

@@ -2,19 +2,19 @@ java_import java.io.IOException
 java_import java.nio.ByteBuffer
 java_import java.nio.channels.SelectionKey
 
+require 'zmachine'
+
 module ZMachine
   class Connection
 
     extend Forwardable
 
     attr_accessor :channel
-    attr_accessor :args
-    attr_accessor :block
 
-    def self.new(*args, &block)
+    def self.new(*args)
       allocate.instance_eval do
-        initialize(*args, &block)
-        @args, @block = args, block
+        initialize(*args)
+        @args = args
         post_init
         self
       end
@@ -22,48 +22,52 @@ module ZMachine
 
     # channel type dispatch
 
-    def bind(address, port_or_type)
+    def bind(address, port_or_type, &block)
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self) if ZMachine.debug
-      if address =~ %r{\w+://}
-        @channel = ZMQChannel.new(port_or_type)
-        @channel.bind(address)
-      else
-        @channel = TCPChannel.new
-        @channel.bind(address, port_or_type)
-      end
+      klass = (address =~ %r{\w+://}) ? ZMQChannel : TCPChannel
+      @channel = klass.new
+      @channel.bind(address, port_or_type)
+      @block = block
       self
     end
 
-    def connect(address, port_or_type)
+    def connect(address, port_or_type, &block)
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self) if ZMachine.debug
-      if address.nil? or address =~ %r{\w+://}
-        @channel = ZMQChannel.new(port_or_type)
-        @channel.connect(address) if address
-      else
-        @channel = TCPChannel.new
-        @channel.connect(address, port_or_type)
-      end
-      if @connect_timeout
-        @timer = ZMachine.add_timer(@connect_timeout) do
-          ZMachine.reactor.close_connection(self)
-        end
-      end
+      klass = (address.nil? || address =~ %r{\w+://}) ? ZMQChannel : TCPChannel
+      @channel = klass.new
+      @channel.connect(address, port_or_type) if address
+      yield self if block_given?
+      renew_timer
       self
     end
 
+    # callbacks
+    def connection_accepted
+    end
+
+    def connection_completed
+    end
+
+    def post_init
+    end
+
+    def receive_data(data)
+    end
+
+    def unbind
+    end
+
+    # EventMachine Connection API
+
     def_delegator :@channel, :bound?
     def_delegator :@channel, :closed?
     def_delegator :@channel, :connected?
     def_delegator :@channel, :connection_pending?
 
-    # EventMachine Connection API
-
-    def _not_implemented
-      raise RuntimeError.new("API call not implemented! #{caller[0]}")
-    end
-
     def close_connection(after_writing = false)
-      @channel.close(after_writing)
+      @channel.close(after_writing) do
+        ZMachine.close_connection(self)
+      end
     end
 
     alias :close :close_connection
@@ -84,160 +88,51 @@ module ZMachine
 
     alias :set_comm_inactivity_timeout :comm_inactivity_timeout=
 
-    def connection_accepted(channel)
-    end
-
-    def connection_completed
-    end
-
-    def detach
-      _not_implemented
-    end
-
-    def error?
-      _not_implemented
-    end
-
     def get_idle_time
       (System.nano_time - @last_activity) / 1_000_000
     end
 
-    def get_peer_cert
-      _not_implemented
-    end
-
     def get_peername
       if peer = @channel.peer
         ::Socket.pack_sockaddr_in(*peer)
       end
     end
 
-    def get_pid
-      _not_implemented
-    end
-
-    def get_proxied_bytes
-      _not_implemented
-    end
-
-    def get_sock_opt(level, option)
-      _not_implemented
-    end
-
-    def get_sockname
-      _not_implemented
-    end
-
-    def get_status
-      _not_implemented
-    end
-
-    def notify_readable=(mode)
-      _not_implemented
-    end
-
     def notify_readable?
       true
     end
 
-    def notify_writable=(mode)
-      _not_implemented
-    end
-
     def notify_writable?
       @channel.can_send?
     end
 
-    def pause
-      _not_implemented
-    end
-
-    def paused?
-      _not_implemented
-    end
-
     def pending_connect_timeout=(value)
       @connect_timeout = value
     end
 
     alias :set_pending_connect_timeout :pending_connect_timeout=
 
-    def post_init
-    end
-
-    def proxy_completed
-      _not_implemented
-    end
-
-    def proxy_incoming_to(conn, bufsize = 0)
-      _not_implemented
-    end
-
-    def proxy_target_unbound
-      _not_implemented
-    end
-
-    def receive_data(data)
-    end
-
     def reconnect(server, port_or_type)
       ZMachine.reconnect(server, port_or_type, self)
     end
 
-    def resume
-      _not_implemented
-    end
-
     def send_data(data)
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self) if ZMachine.debug
+      data = data.to_java_bytes if data.is_a?(String) # EM compat
       @channel.send_data(data)
       update_events
     end
 
-    def send_datagram(data, recipient_address, recipient_port)
-      _not_implemented
-    end
-
-    def send_file_data(filename)
-      _not_implemented
-    end
-
-    def set_sock_opt(level, optname, optval)
-      _not_implemented
-    end
-
-    def ssl_handshake_completed
-      _not_implemented
-    end
-
-    def ssl_verify_peer(cert)
-      _not_implemented
-    end
-
-    def start_tls(args = {})
-      _not_implemented
-    end
-
-    def stop_proxying
-      _not_implemented
-    end
-
-    def stream_file_data(filename, args = {})
-      _not_implemented
-    end
-
-    def unbind
-    end
-
     # triggers
 
     def acceptable!
       client = @channel.accept
-      connection_accepted(client) if client.connected?
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self, client: client) if ZMachine.debug
-      self.class.new(*@args, &@block).tap do |instance|
-        instance.channel = client
-      end
+      connection = self.class.new(*@args)
+      connection.channel = client
+      @block.call(connection) if @block
+      connection.connection_accepted
+      connection
     end
 
     def connectable!
@@ -273,8 +168,13 @@ module ZMachine
       @channel_key ||= @channel.selectable_fd.register(selector, current_events, self)
     end
 
+    def valid?
+      @channel_key &&
+      @channel_key.valid?
+    end
+
     def update_events
-      return unless @channel_key
+      return unless valid?
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self) if ZMachine.debug
       @channel_key.interest_ops(current_events)
     end
@@ -301,7 +201,7 @@ module ZMachine
     end
 
     def process_events
-      return unless @channel_key
+      return unless valid?
       ZMachine.logger.debug("zmachine:connection:#{__method__}", connection: self) if ZMachine.debug
       if @channel_key.connectable?
         connectable!
@@ -311,6 +211,9 @@ module ZMachine
         writable! if @channel_key.writable?
         readable! if @channel_key.readable?
       end
+    rescue Java::JavaNioChannels::CancelledKeyException
+      # channel may have been closed by write handler. ignore exception and
+      # wait for cleanup
     end
 
     def mark_active!
@@ -320,8 +223,10 @@ module ZMachine
 
     def renew_timer
       @timer.cancel if @timer
-      @timer = ZMachine.add_timer(@inactivity_timeout) do
-        ZMachine.reactor.close_connection(self)
+      if connection_pending? && @connect_timeout
+        @timer = ZMachine.add_timer(@connect_timeout) { ZMachine.close_connection(self, Errno::ETIMEDOUT) }
+      elsif @inactivity_timeout
+        @timer = ZMachine.add_timer(@inactivity_timeout) { ZMachine.close_connection(self, Errno::ETIMEDOUT) }
       end
     end