eventmachine 0.12.8-java → 0.12.10-java

data/lib/jeventmachine.rb

@@ -29,6 +29,32 @@
 
 require 'java'
 require 'em_reactor'
+require 'socket'
+
+java_import java.io.FileDescriptor
+java_import java.nio.channels.SocketChannel
+java_import java.lang.reflect.Field
+
+module JavaFields
+  def set_field(key, value)
+    field = getClass.getDeclaredField(key)
+    field.setAccessible(true)
+    if field.getType.toString == 'int'
+      field.setInt(self, value)
+    else
+      field.set(self, value)
+    end
+  end
+
+  def get_field(key)
+    field = getClass.getDeclaredField(key)
+    field.setAccessible(true)
+    field.get(self)
+  end
+end
+
+FileDescriptor.send :include, JavaFields
+SocketChannel.send :include, JavaFields
 
 module EventMachine
   # TODO: These event numbers are defined in way too many places.
@@ -39,20 +65,29 @@ module EventMachine
   ConnectionAccepted = 103
   ConnectionCompleted = 104
   LoopbreakSignalled = 105
+  ConnectionNotifyReadable = 106
+  ConnectionNotifyWritable = 107
+  SslHandshakeCompleted = 108
+
+  # Exceptions that are defined in rubymain.cpp
+  class ConnectionNotBound < RuntimeError; end
+  class UnknownTimerFired < RuntimeError; end
+  class Unsupported < RuntimeError; end
 
   # This thunk class used to be called EM, but that caused conflicts with
   # the alias "EM" for module EventMachine. (FC, 20Jun08)
   class JEM < com.rubyeventmachine.EmReactor
-    def eventCallback a1, a2, a3
-      s = String.from_java_bytes(a3.array[a3.position...a3.limit])
-      EventMachine::event_callback a1, a2, s
-    end
-  end
-  class Connection < com.rubyeventmachine.Connection
-    def associate_callback_target sig
-      # No-op for the time being.
+    def eventCallback a1, a2, a3, a4
+      s = String.from_java_bytes(a3.array[a3.position...a3.limit]) if a3
+      EventMachine::event_callback a1, a2, s || a4
+      nil
     end
   end
+  # class Connection < com.rubyeventmachine.Connection
+  #   def associate_callback_target sig
+  #     # No-op for the time being.
+  #   end
+  # end
   def self.initialize_event_machine
     @em = JEM.new
   end
@@ -88,7 +123,7 @@ module EventMachine
     bind_connect_server nil, nil, server, port
   end
   def self.bind_connect_server bind_addr, bind_port, server, port
-    @em.connectTcpServer bind_addr, bind_port, server, port
+    @em.connectTcpServer bind_addr, bind_port.to_i, server, port
   end
   def self.close_connection sig, after_writing
     @em.closeConnection sig, after_writing
@@ -112,6 +147,18 @@ module EventMachine
     # Epoll is a no-op for Java.
     # The latest Java versions run epoll when possible in NIO.
   end
+  def self.epoll= val
+  end
+  def self.kqueue
+  end
+  def self.kqueue= val
+  end
+  def self.epoll?
+    false
+  end
+  def self.kqueue?
+    false
+  end
   def self.set_rlimit_nofile n_descriptors
     # Currently a no-op for Java.
   end
@@ -128,10 +175,78 @@ module EventMachine
   end
   def self.set_max_timer_count num
     # harmless no-op in Java. There's no built-in timer limit.
+    @max_timer_count = num
+  end
+  def self.get_max_timer_count
+    # harmless no-op in Java. There's no built-in timer limit.
+    @max_timer_count || 100_000
   end
   def self.library_type
     :java
   end
+  def self.get_peername sig
+    if peer = @em.getPeerName(sig)
+      Socket.pack_sockaddr_in *peer
+    end
+  end
+  def self.attach_fd fileno, watch_mode
+    # 3Aug09: We could pass in the actual SocketChannel, but then it would be modified (set as non-blocking), and
+    # we would need some logic to make sure detach_fd below didn't clobber it. For now, we just always make a new
+    # SocketChannel for the underlying file descriptor
+    # if fileno.java_kind_of? SocketChannel
+    #   ch = fileno
+    #   ch.configureBlocking(false)
+    #   fileno = nil
+    # elsif fileno.java_kind_of? java.nio.channels.Channel
+
+    if fileno.java_kind_of? java.nio.channels.Channel
+      field = fileno.getClass.getDeclaredField('fdVal')
+      field.setAccessible(true)
+      fileno = field.get(fileno)
+    else
+      raise ArgumentError, 'attach_fd requires Java Channel or POSIX fileno' unless fileno.is_a? Fixnum
+    end
+
+    if fileno == 0
+      raise "can't open STDIN as selectable in Java =("
+    elsif fileno.is_a? Fixnum
+      # 8Aug09: The following code is specific to the sun jvm's SocketChannelImpl. Is there a cross-platform
+      # way of implementing this? If so, also remember to update EventableSocketChannel#close and #cleanup
+      fd = FileDescriptor.new
+      fd.set_field 'fd', fileno
+
+      ch = SocketChannel.open
+      ch.configureBlocking(false)
+      ch.kill
+      ch.set_field 'fd', fd
+      ch.set_field 'fdVal', fileno
+      ch.set_field 'state', ch.get_field('ST_CONNECTED')
+    end
+
+    @em.attachChannel(ch,watch_mode)
+  end
+  def self.detach_fd sig
+    if ch = @em.detachChannel(sig)
+      ch.get_field 'fdVal'
+    end
+  end
+
+  def self.set_notify_readable sig, mode
+    @em.setNotifyReadable(sig, mode)
+  end
+  def self.set_notify_writable sig, mode
+    @em.setNotifyWritable(sig, mode)
+  end
+
+  def self.is_notify_readable sig
+    @em.isNotifyReadable(sig)
+  end
+  def self.is_notify_writable sig
+    @em.isNotifyWritable(sig)
+  end
+  def self.get_connection_count
+    @em.getConnectionCount
+  end
 
   class Connection
     def associate_callback_target sig

data/tests/test_attach.rb

@@ -34,6 +34,7 @@ class TestAttach < Test::Unit::TestCase
 
   class EchoClient < EM::Connection
     def initialize
+      self.notify_readable = true
       $sock.write("abc\n")
     end
 
@@ -54,16 +55,17 @@ class TestAttach < Test::Unit::TestCase
     EM.run{
       EM.start_server Host, Port, EchoServer
       $sock = TCPSocket.new Host, Port
-      EM.attach $sock, EchoClient
+      EM.watch $sock, EchoClient
     }
 
     assert_equal $read, "abc\n"
-    assert_equal $fd, $sock.fileno
+    unless defined? JRuby # jruby filenos are not real
+      assert_equal $fd, $sock.fileno
+    end
     assert_equal false, $sock.closed?
     assert_equal $sock.readline, "def\n"
   end
 
-
   module PipeWatch
     def notify_readable
       $read = $r.readline
@@ -74,13 +76,36 @@ class TestAttach < Test::Unit::TestCase
   def test_attach_pipe
     EM.run{
       $r, $w = IO.pipe
-      EM.attach $r, PipeWatch
+      EM.watch $r, PipeWatch do |c|
+        c.notify_readable = true
+      end
       $w.write("ghi\n")
     }
 
     assert_equal $read, "ghi\n"
   end
 
+  def test_set_readable
+    EM.run{
+      $r, $w = IO.pipe
+      c = EM.watch $r, PipeWatch do |c|
+        c.notify_readable = false
+      end
+
+      EM.next_tick{
+        $before = c.notify_readable?
+        c.notify_readable = true
+        $after = c.notify_readable?
+      }
+
+      $w.write("jkl\n")
+    }
+
+    assert !$before
+    assert $after
+    assert_equal $read, "jkl\n"
+  end
+
   module PipeReader
     def receive_data data
       $read = data

data/tests/test_basic.rb

@@ -266,8 +266,7 @@ class TestBasic < Test::Unit::TestCase
     x = false
     assert !x
     EM.run do
-      Thread.new { EM.schedule { x = true } }.join
-      EM.stop
+      Thread.new { EM.schedule { x = true; EM.stop } }.join
     end
     assert x
   end

data/tests/test_connection_count.rb

@@ -14,32 +14,22 @@ class TestConnectionCount < Test::Unit::TestCase
 
   module Client
     def connection_completed
-      EM.next_tick{
-        $client_connected = EM.connection_count
-        EM.stop
-      }
-    end
-  end
-
-  module Server
-    def post_init
-      $server_connected = EM.connection_count
+      $client_conns += 1
+      EM.stop if $client_conns == 3
     end
   end
 
   def test_with_some_connections
     EM.run {
-      $initial = EM.connection_count
-      EM.start_server("127.0.0.1", 9999, Server)
-      $server_started = EM.connection_count
-      EM.next_tick{
-        EM.connect("127.0.0.1", 9999, Client)
-      }
+      $client_conns = 0
+      $initial_conns = EM.connection_count
+      EM.start_server("127.0.0.1", 9999)
+      $server_conns = EM.connection_count
+      3.times { EM.connect("127.0.0.1", 9999, Client) }
     }
 
-    assert_equal(0, $initial)
-    assert_equal(1, $server_started)
-    assert_equal(2, $server_connected)
-    assert_equal(3, $client_connected)
+    assert_equal(0, $initial_conns)
+    assert_equal(1, $server_conns)
+    assert_equal(4, $client_conns + $server_conns)
   end
 end

data/tests/test_epoll.rb

@@ -94,7 +94,6 @@ class TestEpoll < Test::Unit::TestCase
     n = 0
     work_proc = proc {n += 1}
     callback_proc = proc {EM.stop}
-    EM.epoll
     EM.run {
       EM.defer work_proc, callback_proc
     }
@@ -120,7 +119,6 @@ class TestEpoll < Test::Unit::TestCase
 
   def test_datagrams
     $in = $out = ""
-    EM.epoll
     EM.run {
       EM.open_datagram_socket "127.0.0.1", 9500, TestDatagramServer
       EM.open_datagram_socket "127.0.0.1", 0, TestDatagramClient

data/tests/test_get_sock_opt.rb

@@ -0,0 +1,30 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+class TestGetSockOpt < Test::Unit::TestCase
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_get_sock_opt
+    test = self
+    EM.run do
+      EM.connect 'google.com', 80, Module.new {
+        define_method :connection_completed do
+          val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_ERROR
+          test.assert_equal "\0\0\0\0", val
+          EM.stop
+        end
+      }
+    end
+  end
+end

data/tests/test_httpclient2.rb

@@ -80,7 +80,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get "/"
       d.callback {
         content = d.content
@@ -96,7 +96,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def _test_get_multiple
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get "/"
       d.callback {
         e = http.get "/"
@@ -112,7 +112,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get_pipeline
     headers, headers2 = nil, nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.microsoft.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get("/")
       d.callback {
         headers = d.headers

data/tests/test_inactivity_timeout.rb

@@ -15,7 +15,7 @@ class TestInactivityTimeout < Test::Unit::TestCase
     assert_equal(0.0, $timeout)
   end
 
-  def test_with_set
+  def test_set_and_get
     $timeout = nil
     EM.run {
       c = EM.connect("127.0.0.1", 54321)
@@ -27,4 +27,24 @@ class TestInactivityTimeout < Test::Unit::TestCase
     assert_equal(2.5, $timeout)
   end
 
+  module TimeoutHandler
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_for_real
+    EM.run {
+      EM.heartbeat_interval = 0.1
+      EM.start_server("127.0.0.1", 12345)
+      EM.add_timer(0.2) {
+        $start = Time.now
+        c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
+        c.comm_inactivity_timeout = 2.5
+      }
+    }
+
+    assert_in_delta(2.5, (Time.now - $start), 0.3)
+  end
+
 end

data/tests/test_ltp.rb

@@ -58,9 +58,6 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
 
 
   def test_simple_lines
-    # THIS TEST CURRENTLY FAILS IN JRUBY.
-    assert( RUBY_PLATFORM !~ /java/ )
-
     lines_received = []
     EventMachine.run {
       EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
@@ -85,9 +82,6 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
   end
 
   def test_overlength_lines
-    # THIS TEST CURRENTLY FAILS IN JRUBY.
-    assert( RUBY_PLATFORM !~ /java/ )
-
     lines_received = []
     EventMachine.run {
       EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|

data/tests/test_next_tick.rb

@@ -33,7 +33,6 @@ class TestNextTick < Test::Unit::TestCase
 
   def test_tick_arg
     pr = proc {EM.stop}
-    EM.epoll
     EM.run {
       EM.next_tick pr
     }
@@ -41,7 +40,6 @@ class TestNextTick < Test::Unit::TestCase
   end
 
   def test_tick_block
-    EM.epoll
     EM.run {
       EM.next_tick {EM.stop}
     }

data/tests/test_pause.rb

@@ -0,0 +1,70 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+class TestPause < Test::Unit::TestCase
+  TestHost = "127.0.0.1"
+  TestPort = 9070
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_pause_resume
+    test = self
+    server = nil
+
+    s_rx = c_rx = 0
+
+    EM.run do
+      EM.start_server TestHost, TestPort, Module.new {
+        define_method :post_init do
+          server = self
+        end
+
+        define_method :receive_data do |data|
+          s_rx += 1
+
+          EM.add_periodic_timer(0.01) { send_data 'hi' }
+          send_data 'hi'
+
+          # pause server, now no outgoing data will actually
+          # be sent and no more incoming data will be received
+          pause
+        end
+      }
+
+      c = EM.connect TestHost, TestPort, Module.new {
+        define_method :receive_data do |data|
+          c_rx += 1
+        end
+      }
+      EM.add_periodic_timer(0.01) { c.send_data 'hi' }
+
+      EM.add_timer(1) do
+        test.assert_equal 1, s_rx
+        test.assert_equal 0, c_rx
+        test.assert server.paused?
+
+        # resume server, queued outgoing and incoming data will be flushed
+        server.resume
+
+        test.assert ! server.paused?
+
+        EM.add_timer(1) do
+          test.assert server.paused?
+          test.assert s_rx >= 2
+          test.assert c_rx >= 1
+          EM.stop_event_loop
+        end
+      end
+    end
+  end
+end