zmachine 0.1.3 → 0.2.0

data/lib/zmachine/tcp_channel.rb

@@ -1,3 +1,6 @@
+java_import java.io.IOException
+java_import java.net.InetSocketAddress
+java_import java.nio.channels.SocketChannel
 java_import java.nio.channels.ServerSocketChannel
 
 require 'zmachine/channel'
@@ -5,93 +8,81 @@ require 'zmachine/channel'
 module ZMachine
   class TCPChannel < Channel
 
-    attr_reader :connect_pending
-
-    def initialize(selector)
-      super(selector)
-      @close_scheduled = false
-      @connect_pending = false
-      @server_socket   = false
-    end
-
-    def register
-      @channel_key ||= @socket.register(@selector, current_events, self)
+    def selectable_fd
+      @socket
     end
 
     def bind(address, port)
-      @server_socket = true
       address = InetSocketAddress.new(address, port)
       @socket = ServerSocketChannel.open
       @socket.configure_blocking(false)
       @socket.bind(address)
     end
 
+    def bound?
+      @socket.is_a?(ServerSocketChannel) and @socket.bound?
+    end
+
     def accept
-      client_socket = socket.accept
+      client_socket = @socket.accept
       return unless client_socket
       client_socket.configure_blocking(false)
-      channel = TCPChannel.new(@selector)
-      channel.socket = client_socket
-      channel
+      TCPChannel.new.tap do |channel|
+        channel.socket = client_socket
+      end
     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_connection(flush = true)
-      @reactor.unbind_channel(self) if schedule_close(flush)
+    def connection_pending?
+      @socket.connection_pending?
     end
 
-    def close
-      if @channel_key
-        @channel_key.cancel
-        @channel_key = nil
-      end
-
-      @socket.close rescue nil
+    def finish_connecting
+      return unless connection_pending?
+      @socket.finish_connect # XXX: finish_connect might return false
+      return true
     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
+    def connected?
+      @socket.connected?
     end
 
-    def read_inbound_data(buffer)
+    def read_inbound_data
+      buffer = @inbound_buffer
       buffer.clear
-      raise IOException.new("eof") if @socket.read(buffer) == -1
+      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 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
-      until @outbound_queue.empty?
+      while can_send?
         buffer = @outbound_queue.first
-        @socket.write(buffer) if buffer.remaining > 0
+        @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.
@@ -102,80 +93,27 @@ module ZMachine
         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
+      if can_send?
+        # network buffers are full
         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]
+      close if @close_scheduled
+      return true
     end
 
-    def connect_pending=(value)
-      @connect_pending = value
-      update_events
+    def close(after_writing = false)
+      super
+      @socket.close unless can_send?
     end
 
-    def update_events
-      return unless @channel_key
-      events = current_events
-      if @channel_key.interest_ops != events
-        @channel_key.interest_ops(events)
-      end
+    def closed?
+      @socket.socket.closed?
     end
 
-    # these two are a bit misleading .. only used for the zmq channel
-    def has_more?
-      false
+    def peer
+      [@socket.socket.port, @socket.socket.inet_address.host_address]
     end
 
-    def can_send?
-      false
-    end
-
-    def current_events
-      if @socket.is_a?(ServerSocketChannel)
-        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/zmq_channel.rb

@@ -1,144 +1,96 @@
+require 'zmachine/jeromq-0.3.0-SNAPSHOT.jar'
 java_import org.zeromq.ZMQ
-java_import org.zeromq.ZMsg
 java_import org.zeromq.ZMQException
 
+require 'zmachine'
 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
+    # 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_array, :send, [[].to_java(:byte).java_class, Java::int]
+    java_alias :recv_byte_array, :recv, [Java::int]
   end
 end
 
 module ZMachine
   class ZMQChannel < Channel
 
-    attr_reader :port
-    attr_reader :socket
-
-    def initialize(type, selector)
-      super(selector)
-      @socket = ZMQChannel.create_socket_with_opts type, linger: 0
+    def initialize(type)
+      super()
+      @socket = ZMachine.context.create_socket(type)
+      @bound = false
+      @connected = false
+      @closed = false
     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
+    def selectable_fd
+      @socket.fd
     end
 
-    def register
-      @channel_key ||= @socket.fd.register(@selector, current_events, self)
+    def bind(address, port = nil)
+      @bound = true
+      @socket.bind(address)
     end
 
-    def bind(address)
-      @port = @socket.bind(address)
+    def bound?
+      @bound
     end
 
     def connect(address)
-      @socket.connect(address) if address
+      @connected = true
+      @socket.connect(address)
     end
 
-    def identity=(value)
-      @socket.identity = value.to_java_bytes
+    def connection_pending?
+      false
     end
 
-    def close
-      if @channel_key
-        @channel_key.cancel
-        @channel_key = nil
-      end
+    def connected?
+      @connected
+    end
 
-      @socket.close
+    def read_inbound_data
+      data = [@socket.recv_byte_array(0)]
+      while @socket.hasReceiveMore
+        data << @socket.recv_byte_array(0)
+      end
+      data
     end
 
     def send_data(data)
-      @outbound_queue << data unless send_msg(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
 
-    def send2(a,b)
-      @socket.send2 a,b
+    # 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 send3(a,b,c)
-      @socket.send3 a,b,c
+    def send2(a, b)
+      @socket.send_byte_array(a, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(b, ZMQ::DONTWAIT)
     end
 
-    def send_msg(msg)
-      msg.post(@socket, true)
-      return true
-    rescue ZMQException => e
-      return false
+    def send3(a, b, c)
+      @socket.send_byte_array(a, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(b, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(c, ZMQ::DONTWAIT)
     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
+    def send4(a, b, c, d)
+      @socket.send_byte_array(a, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(b, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(c, ZMQ::DONTWAIT | ZMQ::DONTWAIT)
+      @socket.send_byte_array(d, ZMQ::DONTWAIT)
     end
 
     def has_more?
@@ -146,26 +98,33 @@ module ZMachine
     end
 
     def can_send?
-      @socket.events & ZMQ::Poller::POLLOUT == ZMQ::Poller::POLLOUT
+      super and (@socket.events & ZMQ::Poller::POLLOUT == ZMQ::Poller::POLLOUT)
     end
 
-    def schedule_close(after_writing)
-      true
+    def write_outbound_data
+      while can_send?
+        data = @outbound_queue.shift
+        send_data(data)
+      end
+
+      close if @close_scheduled
+      return true
     end
 
-    # TODO: fix me
-    def peer_name
-      sock = @socket.socket
-      [sock.port, sock.inet_address.host_address]
+    def close(after_writing = false)
+      super
+      @closed = true
+      @connected = false
+      @bound = false
+      ZMachine.context.destroySocket(@socket) unless can_send?
     end
 
-    def sock_name
-      sock = @socket.socket
-      [sock.local_port, sock.local_address.host_address]
+    def closed?
+      @closed
     end
 
-    def current_events
-      SelectionKey::OP_READ
+    def peer
+      raise RuntimeError.new("ZMQChannel has no peer")
     end
 
   end