eventmachine 1.0.3-x86-mingw32 → 1.2.0.dev.2-x86-mingw32

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
 
@@ -66,7 +89,15 @@ module EventMachine
 
       def post_init
         @requests = {}
-        EM.add_periodic_timer(0.1, &method(:tick))
+      end
+
+      def start_timer
+        @timer ||= EM.add_periodic_timer(0.1, &method(:tick))
+      end
+
+      def stop_timer
+        EM.cancel_timer(@timer)
+        @timer = nil
       end
 
       def unbind
@@ -84,6 +115,13 @@ module EventMachine
         else
           @requests[id] = req
         end
+
+        start_timer
+      end
+
+      def deregister_request(id, req)
+        @requests.delete(id)
+        stop_timer if @requests.length == 0
       end
 
       def send_packet(pkt)
@@ -109,6 +147,7 @@ module EventMachine
           req = @requests[msg.id]
           if req
             @requests.delete(msg.id)
+            stop_timer if @requests.length == 0
             req.receive_answer(msg)
           end
         end
@@ -140,6 +179,7 @@ module EventMachine
         if @tries < @max_tries
           send
         else
+          @socket.deregister_request(@id, self)
           fail 'retries exceeded'
         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/tick_loop.rb

@@ -7,25 +7,25 @@ module EventMachine
   # A TickLoop is useful when one needs to distribute amounts of work
   # throughout ticks in order to maintain response times. It is also useful for
   # simple repeated checks and metrics.
-  # 
-  #   # Here we run through an array one item per tick until it is empty, 
-  #   # printing each element.
-  #   # When the array is empty, we return :stop from the callback, and the
-  #   # loop will terminate.
-  #   # When the loop terminates, the on_stop callbacks will be called.
-  #   EM.run do
-  #     array = (1..100).to_a
-  #   
-  #     tickloop = EM.tick_loop do
-  #       if array.empty?
-  #         :stop
-  #       else
-  #         puts array.shift
-  #       end
-  #     end
-  #   
-  #     tickloop.on_stop { EM.stop }
-  #   end
+  # @example
+  #    # Here we run through an array one item per tick until it is empty, 
+  #    # printing each element.
+  #    # When the array is empty, we return :stop from the callback, and the
+  #    # loop will terminate.
+  #    # When the loop terminates, the on_stop callbacks will be called.  
+  #    EM.run do
+  #      array = (1..100).to_a
+  #      
+  #      tickloop = EM.tick_loop do
+  #        if array.empty?
+  #          :stop
+  #        else
+  #          puts array.shift
+  #        end
+  #      end
+  #      
+  #      tickloop.on_stop { EM.stop }
+  #    end
   #
   class TickLoop
 

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.3"
+  VERSION = "1.2.0.dev.2"
 end

data/lib/eventmachine.rb

@@ -156,11 +156,12 @@ module EventMachine
     # will start without release_machine being called and will immediately throw
 
     #
-    if reactor_running? and @reactor_pid != Process.pid
+    if @reactor_running and @reactor_pid != Process.pid
       # Reactor was started in a different parent, meaning we have forked.
       # Clean up reactor state so a new reactor boots up in this child.
       stop_event_loop
       release_machine
+      cleanup_machine
       @reactor_running = false
     end
 
@@ -184,36 +185,22 @@ module EventMachine
           add_timer(0) { signal_loopbreak }
         end
         @reactor_thread = Thread.current
-        run_machine
+
+        # Rubinius needs to come back into "Ruby space" for GC to work,
+        # so we'll crank the machine here.
+        if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+          while run_machine_once; end
+        else
+          run_machine
+        end
+
       ensure
         until @tails.empty?
           @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
@@ -258,15 +245,32 @@ 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.
   #
   # These callbacks are called in the _reverse_ order to which they are added.
@@ -531,6 +535,15 @@ module EventMachine
     s
   end
 
+  # Attach to an existing socket's file descriptor. The socket may have been
+  # started with {EventMachine.start_server}.
+  def self.attach_server sock, handler=nil, *args, &block
+    klass = klass_from_handler(Connection, handler, *args)
+    sd = sock.respond_to?(:fileno) ? sock.fileno : sock
+    s = attach_sd(sd)
+    @acceptors[s] = [klass,args,block,sock]
+    s
+  end
 
   # Stop a TCP server socket that was started with {EventMachine.start_server}.
   # @see EventMachine.start_server
@@ -737,7 +750,12 @@ module EventMachine
     end
 
     if io.respond_to?(:fileno)
-      fd = defined?(JRuby) ? JRuby.runtime.getDescriptorByFileno(io.fileno).getChannel : io.fileno
+      # getDescriptorByFileno deprecated in JRuby 1.7.x, removed in JRuby 9000
+      if defined?(JRuby) && JRuby.runtime.respond_to?(:getDescriptorByFileno)
+        fd = JRuby.runtime.getDescriptorByFileno(io.fileno).getChannel
+      else
+        fd = io.fileno
+      end
     else
       fd = io
     end
@@ -957,13 +975,16 @@ module EventMachine
       callback = @next_tick_mutex.synchronize { @next_tick_queue.shift }
       begin
         callback.call
+      rescue
+        exception_raised = true
+        raise
       ensure
         # This is a little nasty. The problem is, if an exception occurs during
         # the callback, then we need to send a signal to the reactor to actually
         # do some work during the next_tick. The only mechanism we have from the
         # ruby side is next_tick itself, although ideally, we'd just drop a byte
         # on the loopback descriptor.
-        EM.next_tick {} if $!
+        EM.next_tick {} if exception_raised
       end
     end
   end
@@ -972,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 ##
   #
@@ -990,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 {
@@ -999,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.
     #
@@ -1023,7 +1056,7 @@ module EventMachine
       spawn_threadpool
     end
 
-    @threadqueue << [op||blk,callback]
+    @threadqueue << [op||blk,callback,errback]
   end
 
 
@@ -1033,9 +1066,19 @@ module EventMachine
       thread = Thread.new do
         Thread.current.abort_on_exception = true
         while true
-          op, cback = *@threadqueue.pop
-          result = op.call
-          @resultqueue << [result, cback]
+          begin
+            op, cback, eback = *@threadqueue.pop
+          rescue ThreadError
+            $stderr.puts $!.message
+            break # Ruby 2.0 may fail at Queue.pop
+          end
+          begin
+            result = op.call
+            @resultqueue << [result, cback]
+          rescue Exception => error
+            raise error unless eback
+            @resultqueue << [error, eback]
+          end
           EventMachine.signal_loopbreak
         end
       end
@@ -1181,7 +1224,7 @@ module EventMachine
   #
   # @return [Boolean] true if the EventMachine reactor loop is currently running
   def self.reactor_running?
-    (@reactor_running || false)
+    @reactor_running && Process.pid == @reactor_pid
   end
 
 
@@ -1447,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
@@ -1512,9 +1559,9 @@ module EventMachine
       raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
       handler
     elsif handler
-      begin
+      if defined?(handler::EM_CONNECTION_CLASS)
         handler::EM_CONNECTION_CLASS
-      rescue NameError
+      else
         handler::const_set(:EM_CONNECTION_CLASS, Class.new(klass) {include handler})
       end
     else