eventmachine 1.0.0.beta.3-java → 1.0.0.beta.4-java

data/lib/jeventmachine.rb

@@ -59,14 +59,23 @@ SocketChannel.send :include, JavaFields
 module EventMachine
   # TODO: These event numbers are defined in way too many places.
   # DRY them up.
+  # @private
   TimerFired = 100
+  # @private
   ConnectionData = 101
+  # @private
   ConnectionUnbound = 102
+  # @private
   ConnectionAccepted = 103
+  # @private
   ConnectionCompleted = 104
+  # @private
   LoopbreakSignalled = 105
+  # @private
   ConnectionNotifyReadable = 106
+  # @private
   ConnectionNotifyWritable = 107
+  # @private
   SslHandshakeCompleted = 108
 
   # Exceptions that are defined in rubymain.cpp
@@ -118,7 +127,7 @@ module EventMachine
     @em.sendData sig, data.to_java_bytes
   end
   def self.send_datagram sig, data, length, address, port
-    @em.sendDatagram sig, data, length, address, port
+    @em.sendDatagram sig, data.to_java_bytes, length, address, port
   end
   def self.connect_server server, port
     bind_connect_server nil, nil, server, port
@@ -132,6 +141,10 @@ module EventMachine
   def self.set_comm_inactivity_timeout sig, interval
     @em.setCommInactivityTimeout sig, interval
   end
+  def self.set_pending_connect_timeout sig, val
+  end
+  def self.set_heartbeat_interval val
+  end
   def self.start_tls sig
     @em.startTls sig
   end
@@ -190,6 +203,7 @@ module EventMachine
       Socket.pack_sockaddr_in(*peer)
     end
   end
+  # @private
   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
@@ -249,6 +263,13 @@ module EventMachine
     @em.getConnectionCount
   end
 
+  def self.set_tls_parms(sig, params)
+  end
+  def self.start_tls(sig)
+  end
+  def self.send_file_data(sig, filename)
+  end
+
   class Connection
     def associate_callback_target sig
       # No-op for the time being

data/tasks/package.rake

@@ -1,6 +1,16 @@
 require 'rake/gempackagetask'
-require 'rake/extensiontask'
-require 'rake/javaextensiontask'
+begin
+  require 'rake/extensiontask'
+  require 'rake/javaextensiontask'
+rescue LoadError => e
+  puts <<-MSG
+rake-compiler gem seems to be missing. Please install it with
+
+  gem install rake-compiler
+
+(add sudo if necessary).
+  MSG
+end
 
 Rake::GemPackageTask.new(GEMSPEC) do |pkg|
 end
@@ -13,7 +23,7 @@ else
   def setup_cross_compilation(ext)
     unless RUBY_PLATFORM =~ /mswin|mingw/
       ext.cross_compile = true
-      ext.cross_platform = ['x86-mingw32', 'x86-mswin32-60']
+      ext.cross_platform = ['x86-mingw32']#, 'x86-mswin32-60']
 
       # inject 1.8/1.9 pure-ruby entry point
       ext.cross_compiling do |spec|

data/tasks/test.rake

@@ -2,6 +2,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "tests"
+  t.libs << "lib"
   t.pattern = 'tests/**/test_*.rb'
   t.warning = true
 end

data/tests/em_test_helper.rb

@@ -1,9 +1,9 @@
-require 'lib/eventmachine'
+require 'eventmachine'
 require 'test/unit'
 require 'rbconfig'
 require 'socket'
 
-Test::Unit::TestCase.class_eval do
+class Test::Unit::TestCase
   class EMTestTimeout < StandardError ; end
 
   def setup_timeout(timeout = TIMEOUT_INTERVAL)
@@ -38,7 +38,7 @@ Test::Unit::TestCase.class_eval do
   module PlatformHelper
     # http://blog.emptyway.com/2009/11/03/proper-way-to-detect-windows-platform-in-ruby/
     def windows?
-      Config::CONFIG['host_os'] =~ /mswin|mingw/
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     end
 
     # http://stackoverflow.com/questions/1342535/how-can-i-tell-if-im-running-from-jruby-vs-ruby/1685970#1685970
@@ -52,4 +52,13 @@ Test::Unit::TestCase.class_eval do
 
   # Tests run significantly slower on windows. YMMV
   TIMEOUT_INTERVAL = windows? ? 1 : 0.25
+
+  def silent
+    backup, $VERBOSE = $VERBOSE, nil
+    begin
+      yield
+    ensure
+      $VERBOSE = backup
+    end
+  end
 end

data/tests/test_completion.rb

@@ -0,0 +1,177 @@
+require 'em/completion'
+
+class TestCompletion < Test::Unit::TestCase
+  def completion
+    @completion ||= EM::Completion.new
+  end
+
+  def crank
+    # This is a slow solution, but this just executes the next tick queue
+    # once. It's the easiest way for now.
+    EM.run { EM.stop }
+  end
+
+  def results
+    @results ||= []
+  end
+
+  def test_state
+    assert_equal :unknown, completion.state
+  end
+
+  def test_succeed
+    completion.callback { |val| results << val }
+    completion.succeed :object
+    crank
+    assert_equal :succeeded, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_fail
+    completion.errback { |val| results << val }
+    completion.fail :object
+    crank
+    assert_equal :failed, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_callback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.succeed
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_errback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:errback], results
+  end
+
+  def test_stateback
+    completion.stateback(:magic) { results << :stateback }
+    completion.change_state(:magic)
+    crank
+    assert_equal [:stateback], results
+  end
+
+  def test_does_not_enqueue_when_completed
+    completion.callback { results << :callback }
+    completion.succeed
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_completed
+    assert_equal false, completion.completed?
+    completion.succeed
+    assert_equal true, completion.completed?
+    completion.fail
+    assert_equal true, completion.completed?
+    completion.change_state :magic
+    assert_equal false, completion.completed?
+  end
+
+  def test_recursive_callbacks
+    completion.callback do |val|
+      results << val
+      completion.succeed :two
+    end
+    completion.callback do |val|
+      results << val
+      completion.succeed :three
+    end
+    completion.callback do |val|
+      results << val
+    end
+    completion.succeed :one
+    crank
+    assert_equal [:one, :two, :three], results
+  end
+
+  def test_late_defined_callbacks
+    completion.callback { results << :one }
+    completion.succeed
+    crank
+    assert_equal [:one], results
+    completion.callback { results << :two }
+    crank
+    assert_equal [:one, :two], results
+  end
+
+  def test_cleared_completions
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+
+    completion.succeed
+    crank
+    completion.fail
+    crank
+    completion.succeed
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_skip_completed_callbacks
+    completion.callback { results << :callback }
+    completion.succeed
+    crank
+
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_completions
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    assert_equal [:completion], results
+
+    completion.change_state(:unknown)
+    results.clear
+
+    completion.completion { results << :completion }
+    completion.fail
+    crank
+    assert_equal [:completion], results
+  end
+
+  def test_latent_completion
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    completion.completion { results << :completion }
+    crank
+    assert_equal [:completion, :completion], results
+  end
+
+  def test_timeout
+    args = [1, 2, 3]
+    EM.run do
+      completion.timeout(0.0001, *args)
+      completion.errback { |*errargs| results << errargs }
+      completion.completion { EM.stop }
+      EM.add_timer(0.1) { flunk 'test timed out' }
+    end
+    assert_equal [[1,2,3]], results
+  end
+
+  def test_timeout_gets_cancelled
+    EM.run do
+      completion.timeout(0.0001, :timeout)
+      completion.errback  { results << :errback  }
+      completion.succeed
+      EM.add_timer(0.0002) { EM.stop }
+    end
+    assert_equal [], results
+  end
+end

data/tests/test_epoll.rb

@@ -49,7 +49,7 @@ class TestEpoll < Test::Unit::TestCase
   # XXX this test causes all sort of weird issues on OSX (when run as part of the suite)
   def _test_descriptors
     EM.epoll
-    s = EM.set_descriptor_table_size 60000
+    EM.set_descriptor_table_size 60000
     EM.run {
       EM.start_server "127.0.0.1", 9800, TestEchoServer
       $n = 0
@@ -101,7 +101,7 @@ class TestEpoll < Test::Unit::TestCase
   def _test_unix_domain
     fn = "/tmp/xxx.chain"
     EM.epoll
-    s = EM.set_descriptor_table_size 60000
+    EM.set_descriptor_table_size 60000
     EM.run {
       # The pure-Ruby version won't let us open the socket if the node already exists.
       # Not sure, that actually may be correct and the compiled version is wrong.

data/tests/test_httpclient.rb

@@ -16,7 +16,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client
     ok = false
     EM.run {
-      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
       c.callback {
         ok = true
         EM.stop
@@ -31,7 +31,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client_1
     ok = false
     EM.run {
-      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
       c.callback {ok = true; EM.stop}
       c.errback {EM.stop}
     }
@@ -43,7 +43,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client_2
     ok = false
     EM.run {
-      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
       c.callback {|result|
         ok = true;
         EM.stop
@@ -75,7 +75,7 @@ class TestHttpClient < Test::Unit::TestCase
       ok = false
       EM.run {
         EM.start_server "127.0.0.1", 9701, EmptyContent
-        c = EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+        c = silent { EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => 9701 }
         c.callback {|result|
           ok = true
           EM.stop
@@ -134,14 +134,14 @@ class TestHttpClient < Test::Unit::TestCase
       EM.run {
         EM.start_server Localhost, Localport, PostContent
         setup_timeout(2)
-        c = EM::P::HttpClient.request(
+        c = silent { EM::P::HttpClient.request(
           :host=>Localhost,
           :port=>Localport,
           :method=>:post,
           :request=>"/aaa",
           :content=>"XYZ",
           :content_type=>"text/plain"
-        )
+        )}
         c.callback {|r|
           response = r
           EM.stop
@@ -158,7 +158,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_cookie
     ok = false
     EM.run {
-      c = EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb"
+      c = silent { EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb" }
       c.callback {|result|
         ok = true;
         EM.stop
@@ -173,11 +173,11 @@ class TestHttpClient < Test::Unit::TestCase
   def test_version_1_0
     ok = false
     EM.run {
-      c = EM::P::HttpClient.request(
+      c = silent { EM::P::HttpClient.request(
         :host => "www.google.com",
         :port => 80,
         :version => "1.0"
-      )
+      )}
       c.callback {|result|
         ok = true;
         EM.stop

data/tests/test_httpclient2.rb

@@ -22,8 +22,10 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_connect
     EM.run {
       EM.start_server Localhost, Localport, TestServer
-      http1 = EM::P::HttpClient2.connect Localhost, Localport
-      http2 = EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      silent do
+        EM::P::HttpClient2.connect Localhost, Localport
+        EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      end
       EM.stop
     }
   end
@@ -33,7 +35,7 @@ class TestHttpClient2 < Test::Unit::TestCase
     EM.run {
       EM.start_server Localhost, Localport, TestServer
       assert_raises( ArgumentError ) {
-        EM::P::HttpClient2.connect Localhost, "xxx"
+        silent { EM::P::HttpClient2.connect Localhost, "xxx" }
       }
       EM.stop
     }
@@ -42,7 +44,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_bad_server
     err = nil
     EM.run {
-      http = EM::P::HttpClient2.connect Localhost, 9999
+      http = silent { EM::P::HttpClient2.connect Localhost, 9999 }
       d = http.get "/"
       d.errback { err = true; d.internal_error; EM.stop }
     }
@@ -52,7 +54,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get "/"
       d.callback {
         content = d.content
@@ -68,7 +70,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def _test_get_multiple
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get "/"
       d.callback {
         e = http.get "/"
@@ -84,7 +86,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get_pipeline
     headers, headers2 = nil, nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get("/")
       d.callback {
         headers = d.headers
@@ -104,7 +106,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_authheader
     EM.run {
       EM.start_server Localhost, Localport, TestServer
-      http = EM::P::HttpClient2.connect Localhost, 18842
+      http = silent { EM::P::HttpClient2.connect Localhost, 18842 }
       d = http.get :url=>"/", :authorization=>"Basic xxx"
       d.callback {EM.stop}
       d.errback {EM.stop}
@@ -114,7 +116,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_https_get
     d = nil
     EM.run {
-      http = EM::P::HttpClient2.connect :host => 'www.apple.com', :port => 443, :ssl => true
+      http = silent { EM::P::HttpClient2.connect :host => 'www.apple.com', :port => 443, :ssl => true }
       d = http.get "/"
       d.callback {
         EM.stop