eventmachine 1.0.9.1-java → 1.2.0.1-java

data/lib/em/pool.rb

@@ -143,7 +143,7 @@ module EventMachine
       else
         raise ArgumentError, "deferrable expected from work"
       end
-    rescue Exception
+    rescue
       failure resource
       raise
     end

data/lib/em/protocols/line_and_text.rb

@@ -45,7 +45,7 @@ module EventMachine
             @lpb_buffer.extract(data).each do |line|
               receive_line(line.chomp) if respond_to?(:receive_line)
             end
-          rescue Exception
+          rescue
             receive_error('overlength line') if respond_to?(:receive_error)
             close_connection
             return

data/lib/em/pure_ruby.rb

@@ -66,6 +66,11 @@ module EventMachine
     def release_machine
     end
 
+
+    def stopping?
+      return Reactor.instance.stop_scheduled
+    end
+
     # @private
     def stop
       Reactor.instance.stop
@@ -273,7 +278,7 @@ module EventMachine
 
     HeartbeatInterval = 2
 
-    attr_reader :current_loop_time
+    attr_reader :current_loop_time, :stop_scheduled
 
     def initialize
       initialize_for_run

data/lib/em/queue.rb

@@ -17,7 +17,8 @@ module EventMachine
   #
   class Queue
     def initialize
-      @items = []
+      @sink  = []
+      @drain = []
       @popq  = []
     end
 
@@ -29,10 +30,14 @@ module EventMachine
     def pop(*a, &b)
       cb = EM::Callback(*a, &b)
       EM.schedule do
-        if @items.empty?
+        if @drain.empty?
+          @drain = @sink
+          @sink = []
+        end
+        if @drain.empty?
           @popq << cb
         else
-          cb.call @items.shift
+          cb.call @drain.shift
         end
       end
       nil # Always returns nil
@@ -43,8 +48,12 @@ module EventMachine
     # next reactor tick.
     def push(*items)
       EM.schedule do
-        @items.push(*items)
-        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+        @sink.push(*items)
+        unless @popq.empty?
+          @drain = @sink
+          @sink = []
+          @popq.shift.call @drain.shift until @drain.empty? || @popq.empty?
+        end
       end
     end
     alias :<< :push
@@ -52,13 +61,13 @@ module EventMachine
     # @return [Boolean]
     # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
     def empty?
-      @items.empty?
+      @drain.empty? && @sink.empty?
     end
 
     # @return [Integer] Queue size
     # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
     def size
-      @items.size
+      @drain.size + @sink.size
     end
 
     # @return [Integer] Waiting size

data/lib/em/resolver.rb

@@ -2,30 +2,31 @@ module EventMachine
   module DNS
     class Resolver
 
+      def self.windows?
+        if RUBY_PLATFORM =~ /mswin32|cygwin|mingw|bccwin/
+          require 'win32/resolv'
+          true
+        else
+          false
+        end
+      end
+
+      HOSTS_FILE = windows? ? Win32::Resolv.get_hosts_path : '/etc/hosts'
+
+      @hosts = nil
+      @nameservers = nil
+      @socket = nil
+
       def self.resolve(hostname)
         Request.new(socket, hostname)
       end
 
-      @socket = @nameservers = nil
-
       def self.socket
-        if !@socket || (@socket && @socket.error?)
+        if @socket && @socket.error?
           @socket = Socket.open
-
-          @hosts  = {}
-          IO.readlines('/etc/hosts').each do |line|
-            next if line =~ /^#/
-            addr, host = line.split(/\s+/)
-
-            if @hosts[host]
-              @hosts[host] << addr
-            else
-              @hosts[host] = [addr]
-            end
-          end
+        else
+          @socket ||= Socket.open
         end
-
-        @socket
       end
 
       def self.nameservers=(ns)
@@ -33,15 +34,23 @@ module EventMachine
       end
 
       def self.nameservers
-        if !@nameservers
-          @nameservers = []
-          IO.readlines('/etc/resolv.conf').each do |line|
-            if line =~ /^nameserver (.+)$/
-              @nameservers << $1.split(/\s+/).first
-            end
+        return @nameservers if @nameservers
+
+        if windows?
+          _, ns = Win32::Resolv.get_resolv_info
+          return @nameservers = ns || []
+        end
+
+        @nameservers = []
+        IO.readlines('/etc/resolv.conf').each do |line|
+          if line =~ /^nameserver (.+)$/
+            @nameservers << $1.split(/\s+/).first
           end
         end
+
         @nameservers
+      rescue
+        @nameservers = []
       end
 
       def self.nameserver
@@ -49,7 +58,21 @@ module EventMachine
       end
 
       def self.hosts
+        return @hosts if @hosts
+
+        @hosts = {}
+        IO.readlines(HOSTS_FILE).each do |line|
+          next if line =~ /^#/
+          addr, host = line.split(/\s+/)
+
+          next unless addr && host
+          @hosts[host] ||= []
+          @hosts[host] << addr
+        end
+
         @hosts
+      rescue
+        @hosts = {}
       end
     end
 

data/lib/em/threaded_resource.rb

@@ -71,7 +71,7 @@ module EventMachine
         begin
           result = yield @resource
           completion.succeed result
-        rescue Exception => e
+        rescue => e
           completion.fail e
         end
       end
@@ -87,4 +87,4 @@ module EventMachine
     end
 
   end
-end
+end

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.9.1"
+  VERSION = "1.2.0.1"
 end

data/lib/eventmachine.rb

@@ -161,6 +161,7 @@ module EventMachine
       # Clean up reactor state so a new reactor boots up in this child.
       stop_event_loop
       release_machine
+      cleanup_machine
       @reactor_running = false
     end
 
@@ -198,30 +199,8 @@ module EventMachine
           @tails.pop.call
         end
 
-        begin
-          release_machine
-        ensure
-          if @threadpool
-            @threadpool.each { |t| t.exit }
-            @threadpool.each do |t|
-              next unless t.alive?
-              begin
-                # Thread#kill! does not exist on 1.9 or rbx, and raises
-                # NotImplemented on jruby
-                t.kill!
-              rescue NoMethodError, NotImplementedError
-                t.kill
-                # XXX t.join here?
-              end
-            end
-            @threadqueue = nil
-            @resultqueue = nil
-            @threadpool = nil
-            @all_threads_spawned = false
-          end
-
-          @next_tick_queue = []
-        end
+        release_machine
+        cleanup_machine
         @reactor_running = false
         @reactor_thread = nil
       end
@@ -266,13 +245,30 @@ module EventMachine
     # Original patch by Aman Gupta.
     #
     Kernel.fork do
-      if self.reactor_running?
-        self.stop_event_loop
-        self.release_machine
+      if reactor_running?
+        stop_event_loop
+        release_machine
+        cleanup_machine
         @reactor_running = false
+        @reactor_thread = nil
       end
-      self.run block
+      run block
+    end
+  end
+
+  # Clean up Ruby space following a release_machine
+  def self.cleanup_machine
+    if @threadpool && !@threadpool.empty?
+      # Tell the threads to stop
+      @threadpool.each { |t| t.exit }
+      # Join the threads or bump the stragglers one more time
+      @threadpool.each { |t| t.join 0.01 || t.exit }
     end
+    @threadpool = nil
+    @threadqueue = nil
+    @resultqueue = nil
+    @all_threads_spawned = false
+    @next_tick_queue = []
   end
 
   # Adds a block to call as the reactor is shutting down.
@@ -997,11 +993,14 @@ module EventMachine
   # EventMachine.defer is used for integrating blocking operations into EventMachine's control flow.
   # The action of {.defer} is to take the block specified in the first parameter (the "operation")
   # and schedule it for asynchronous execution on an internal thread pool maintained by EventMachine.
-  # When the operation completes, it will pass the result computed by the block (if any)
-  # back to the EventMachine reactor. Then, EventMachine calls the block specified in the
-  # second parameter to {.defer} (the "callback"), as part of its normal event handling loop.
-  # The result computed by the operation block is passed as a parameter to the callback.
-  # You may omit the callback parameter if you don't need to execute any code after the operation completes.
+  # When the operation completes, it will pass the result computed by the block (if any) back to the
+  # EventMachine reactor. Then, EventMachine calls the block specified in the second parameter to
+  # {.defer} (the "callback"), as part of its normal event handling loop. The result computed by the
+  # operation block is passed as a parameter to the callback. You may omit the callback parameter if
+  # you don't need to execute any code after the operation completes. If the operation raises an
+  # unhandled exception, the exception will be passed to the third parameter to {.defer} (the
+  # "errback"), as part of its normal event handling loop. If no errback is provided, the exception
+  # will be allowed to blow through to the main thread immediately.
   #
   # ## Caveats ##
   #
@@ -1015,6 +1014,11 @@ module EventMachine
   # the number of threads in its pool, so if you do this enough times, your subsequent deferred
   # operations won't get a chance to run.
   #
+  # The threads within the EventMachine's thread pool have abort_on_exception set to true. As a result,
+  # if an unhandled exception is raised by the deferred operation and an errback is not provided, it
+  # will blow through to the main thread immediately. If the main thread is within an indiscriminate
+  # rescue block at that time, the exception could be handled improperly by the main thread.
+  #
   # @example
   #
   #  operation = proc {
@@ -1024,14 +1028,18 @@ module EventMachine
   #  callback = proc {|result|
   #    # do something with result here, such as send it back to a network client.
   #  }
+  #  errback = proc {|error|
+  #    # do something with error here, such as re-raising or logging.
+  #  }
   #
-  #  EventMachine.defer(operation, callback)
+  #  EventMachine.defer(operation, callback, errback)
   #
   # @param [#call] op       An operation you want to offload to EventMachine thread pool
   # @param [#call] callback A callback that will be run on the event loop thread after `operation` finishes.
+  # @param [#call] errback  An errback that will be run on the event loop thread after `operation` raises an exception.
   #
   # @see EventMachine.threadpool_size
-  def self.defer op = nil, callback = nil, &blk
+  def self.defer op = nil, callback = nil, errback = nil, &blk
     # OBSERVE that #next_tick hacks into this mechanism, so don't make any changes here
     # without syncing there.
     #
@@ -1048,7 +1056,7 @@ module EventMachine
       spawn_threadpool
     end
 
-    @threadqueue << [op||blk,callback]
+    @threadqueue << [op||blk,callback,errback]
   end
 
 
@@ -1059,13 +1067,18 @@ module EventMachine
         Thread.current.abort_on_exception = true
         while true
           begin
-            op, cback = *@threadqueue.pop
+            op, cback, eback = *@threadqueue.pop
           rescue ThreadError
             $stderr.puts $!.message
             break # Ruby 2.0 may fail at Queue.pop
           end
-          result = op.call
-          @resultqueue << [result, cback]
+          begin
+            result = op.call
+            @resultqueue << [result, cback]
+          rescue Exception => error
+            raise error unless eback
+            @resultqueue << [error, eback]
+          end
           EventMachine.signal_loopbreak
         end
       end
@@ -1477,9 +1490,13 @@ module EventMachine
             rescue Errno::EBADF, IOError
             end
           end
-        rescue
-          @wrapped_exception = $!
-          stop
+        rescue Exception => e
+          if stopping?
+            @wrapped_exception = $!
+            stop
+          else
+            raise e
+          end
         end
       elsif c = @acceptors.delete( conn_binding )
         # no-op

data/rakelib/package.rake

@@ -25,7 +25,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', 'x64-mingw32']
     end
   end
   def hack_cross_compilation(ext)
@@ -96,3 +96,25 @@ def gem_cmd(action, name, *args)
 end
 
 Rake::Task[:clean].enhance [:clobber_package]
+
+# DevKit task following the example of Luis Lavena's test-ruby-c-extension
+task :devkit do
+  begin
+    require "devkit"
+  rescue LoadError => e
+    abort "Failed to activate RubyInstaller's DevKit required for compilation."
+  end
+end
+
+if RUBY_PLATFORM =~ /mingw|mswin/
+  Rake::Task['compile'].prerequisites.unshift 'devkit'
+end
+
+desc "Build binary gems for Windows with rake-compiler-dock"
+task 'gem:windows' do
+  require 'rake_compiler_dock'
+  RakeCompilerDock.sh <<-EOT
+    RUBY_CC_VERSION="${RUBY_CC_VERSION//1.8.7/}"
+    bundle && rake cross native gem
+  EOT
+end

data/tests/dhparam.pem

@@ -0,0 +1,13 @@
+-----BEGIN DH PARAMETERS-----
+MIICCAKCAgEAikiatXa5aAteOtd6hOO33npjCvJByD3dwuM8rWzz0DFZdUH9nFJi
+b0VvTVweVECb6XZBsrDNLqGQykCrm43swSk5D9XQCGJLxFERD6yk3b90xaeCm3/a
+b0Ek5ZVvV73Cc/YbVmpBiOHoTFpUFJLZ7pLMQUSn8y3qUlNcY9/88HuwFi1s1lRM
+ovihSRyZMYAuYWOD4yuOuIcroKVjD6gWFrsW9XrALWny6vUXQrhk8Q3rj+wM6ZtE
+5afcB0b6ZJtphrDfk3dFjOVG/zVT37VWgrY8GABrpo2ey0W0WIQJ7rDKLaPaI4kc
+voOgC2K8Z3kSARZK+jULnwmBeYECz4EH/FF6FEp3GOKtkL4mqEkvh1n5EAesDOGl
+iiX+RZXcUrZliSeifSXBTMJWWFVC0fkGIMb9PTZfZHyAC54lpuxzVki0HIyQG9Fs
+41zBJ5e8eEoXXlfUYtduUC35YGy2IxSzYLAJE76rctAZSWghha9xLOCDFoLjMr8h
+FosKeHKJcBQ0bc8ymOpRIfrYLWhc0Pz2zkpJ/4eYw9t7NYg7S+jP19IE0gUnuM9v
+SpoYMtS28tP9nEdokdwuBKD0D3bJEBBefDlHgfXoMgvy9Hivc9PBGGNTNpyFPpwF
+sWVAkfhoNMJMC5V7LZsze+lftiDtzVoLSPDa9bO4BK7b/MgwCxfOhGsCAQI=
+-----END DH PARAMETERS-----

data/tests/em_test_helper.rb

@@ -31,6 +31,61 @@ class Test::Unit::TestCase
     @@port
   end
 
+  # Returns true if the host have a localhost 127.0.0.1 IPv4.
+  def self.local_ipv4?
+    return @@has_local_ipv4 if defined?(@@has_local_ipv4)
+    begin
+      get_my_ipv4_address "127.0.0.1"
+      @@has_local_ipv4 = true
+    rescue
+      @@has_local_ipv4 = false
+    end
+  end
+
+  # Returns true if the host have a public IPv4 and stores it in
+  # @@public_ipv4.
+  def self.public_ipv4?
+    return @@has_public_ipv4 if defined?(@@has_public_ipv4)
+    begin
+      @@public_ipv4 = get_my_ipv4_address "1.2.3.4"
+      @@has_public_ipv4 = true
+    rescue
+      @@has_public_ipv4 = false
+    end
+  end
+
+  # Returns true if the host have a localhost ::1 IPv6.
+  def self.local_ipv6?
+    return @@has_local_ipv6 if defined?(@@has_local_ipv6)
+    begin
+      get_my_ipv6_address "::1"
+      @@has_local_ipv6 = true
+    rescue
+      @@has_local_ipv6 = false
+    end
+  end
+
+  # Returns true if the host have a public IPv6 and stores it in
+  # @@public_ipv6.
+  def self.public_ipv6?
+    return @@has_public_ipv6 if defined?(@@has_public_ipv6)
+    begin
+      @@public_ipv6 = get_my_ipv6_address "2001::1"
+      @@has_public_ipv6 = true
+    rescue
+      @@has_public_ipv6 = false
+    end
+  end
+
+  # Returns an array with the localhost addresses (IPv4 and/or IPv6).
+  def local_ips
+    return @@local_ips if defined?(@@local_ips)
+    @@local_ips = []
+    @@local_ips << "127.0.0.1" if self.class.local_ipv4?
+    @@local_ips << "::1" if self.class.local_ipv6?
+    @@local_ips
+  end
+
   def exception_class
     jruby? ? NativeException : RuntimeError
   end
@@ -69,4 +124,28 @@ class Test::Unit::TestCase
       $VERBOSE = backup
     end
   end
+
+
+  private
+
+  def self.get_my_ipv4_address ip
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+    UDPSocket.open(Socket::AF_INET) do |s|
+      s.connect ip, 1
+      s.addr.last
+    end
+  ensure
+    Socket.do_not_reverse_lookup = orig
+  end
+
+  def self.get_my_ipv6_address ip
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+    UDPSocket.open(Socket::AF_INET6) do |s|
+      s.connect ip, 1
+      s.addr.last
+    end
+  ensure
+    Socket.do_not_reverse_lookup = orig
+  end
+
 end