eventmachine 0.12.10 → 1.0.0.beta.1

data/lib/em/protocols/stomp.rb

@@ -106,7 +106,7 @@ module EventMachine
         ary = [verb, "\n"]
         headers.each {|k,v| ary << "#{k}:#{v}\n" }
         ary << "content-length: #{body.to_s.length}\n"
-        ary << "content-type: text/plain; charset=UTF-8\n"
+        ary << "content-type: text/plain; charset=UTF-8\n" unless headers.has_key? 'content-type'
         ary << "\n"
         ary << body.to_s
         ary << "\0"

data/lib/{pr_eventmachine.rb → em/pure_ruby.rb}

@@ -34,10 +34,7 @@ require 'socket'
 require 'fcntl'
 require 'set'
 
-
 module EventMachine
-
-
   class << self
     # This is mostly useful for automated tests.
     # Return a distinctive symbol so the caller knows whether he's dealing
@@ -236,15 +233,8 @@ module EventMachine
   module UuidGenerator
 
     def self.generate
-      if @ix and @ix >= 10000
-        @ix = nil
-        @seed = nil
-      end
-
-      @seed ||= `uuidgen`.chomp.gsub(/-/,"")
       @ix ||= 0
-
-      "#{@seed}#{@ix += 1}"
+      @ix += 1
     end
 
   end

data/lib/em/queue.rb

@@ -45,6 +45,7 @@ module EventMachine
         @popq.shift.call @items.shift until @items.empty? || @popq.empty?
       end
     end
+    alias :<< :push
 
     # N.B. This is a peek, it's not thread safe, and may only tend toward 
     # accuracy.

data/lib/em/streamer.rb

@@ -53,7 +53,7 @@ module EventMachine
       @http_chunks = args[:http_chunks]
 
       if File.exist?(filename)
-        @size = File.size?(filename)
+        @size = File.size(filename)
         if @size <= MappingThreshold
           stream_without_mapping filename
         else

data/lib/em/tick_loop.rb

@@ -0,0 +1,85 @@
+module EventMachine
+  # Creates and immediately starts an EventMachine::TickLoop
+  def self.tick_loop(*a, &b)
+    TickLoop.new(*a, &b).start
+  end
+
+  # 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
+  #
+  class TickLoop
+
+    # Arguments: A callback (EM::Callback) to call each tick. If the call
+    # returns +:stop+ then the loop will be stopped. Any other value is 
+    # ignored.
+    def initialize(*a, &b)
+      @work = EM::Callback(*a, &b)
+      @stops = []
+      @stopped = true
+    end
+
+    # Arguments: A callback (EM::Callback) to call once on the next stop (or
+    # immediately if already stopped).
+    def on_stop(*a, &b)
+      if @stopped
+        EM::Callback(*a, &b).call
+      else
+        @stops << EM::Callback(*a, &b)
+      end
+    end
+
+    # Stop the tick loop immediately, and call it's on_stop callbacks.
+    def stop
+      @stopped = true
+      until @stops.empty?
+        @stops.shift.call
+      end
+    end
+
+    # Query if the loop is stopped.
+    def stopped?
+      @stopped
+    end
+
+    # Start the tick loop, will raise argument error if the loop is already
+    # running.
+    def start
+      raise ArgumentError, "double start" unless @stopped
+      @stopped = false
+      schedule
+    end
+
+    private
+    def schedule
+      EM.next_tick do
+        next if @stopped
+        if @work.call == :stop
+          stop
+        else
+          schedule
+        end
+      end
+      self
+    end
+  end
+end

data/lib/em/timers.rb

@@ -32,6 +32,7 @@ module EventMachine
       @interval = interval
       @code = callback || block
       @cancelled = false
+      @work = method(:fire)
       schedule
     end
 
@@ -44,7 +45,7 @@ module EventMachine
     attr_accessor :interval
 
     def schedule # :nodoc:
-      EventMachine::add_timer @interval, method(:fire)
+      EventMachine::add_timer @interval, @work
     end
     def fire # :nodoc:
       unless @cancelled

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "0.12.10"
+  VERSION = "1.0.0.beta.1"
 end

data/lib/eventmachine.rb

@@ -1,75 +1,12 @@
-#--
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 Apr 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-# 
-
-
-#-- Select in a library based on a global variable.
-# PROVISIONALLY commented out this whole mechanism which selects
-# a pure-Ruby EM implementation if the extension is not available.
-# I expect this will cause a lot of people's code to break, as it
-# exposes misconfigurations and path problems that were masked up
-# till now. The reason I'm disabling it is because the pure-Ruby
-# code will have problems of its own, and it's not nearly as fast
-# anyway. Suggested by a problem report from Moshe Litvin. 05Jun07.
-#
-# 05Dec07: Re-enabled the pure-ruby mechanism, but without the automatic
-# fallback feature that tripped up Moshe Litvin. We shouldn't fail over to
-# the pure Ruby version because it's possible that the user intended to
-# run the extension but failed to do so because of a compilation or
-# similar error. So we require either a global variable or an environment
-# string be set in order to select the pure-Ruby version.
-#
-
-
-unless defined?($eventmachine_library)
-  $eventmachine_library = ENV['EVENTMACHINE_LIBRARY'] || :cascade
-end
-$eventmachine_library = $eventmachine_library.to_sym
-
-case $eventmachine_library
-when :pure_ruby
-  require 'pr_eventmachine'
-when :extension
-  require 'rubyeventmachine'
-when :java
+if RUBY_PLATFORM =~ /java/
+  require 'java'
   require 'jeventmachine'
-else # :cascade
-  # This is the case that most user code will take.
-  # Prefer the extension if available.
+else
   begin
-    if RUBY_PLATFORM =~ /java/
-      require 'java'
-      require 'jeventmachine'
-      $eventmachine_library = :java
-    else
-      require 'rubyeventmachine'
-      $eventmachine_library = :extension
-    end
+    require 'rubyeventmachine'
   rescue LoadError
-    warn "# EventMachine fell back to pure ruby mode" if $DEBUG
-    require 'pr_eventmachine'
-    $eventmachine_library = :pure_ruby
+    warn "Unable to load the EventMachine C extension; To use the pure-ruby reactor, require 'em/pure_ruby'"
+    raise
   end
 end
 
@@ -79,6 +16,7 @@ require 'em/future'
 require 'em/streamer'
 require 'em/spawnable'
 require 'em/processes'
+require 'em/iterator'
 require 'em/buftok'
 require 'em/timers'
 require 'em/protocols'
@@ -88,6 +26,7 @@ require 'em/queue'
 require 'em/channel'
 require 'em/file_watch'
 require 'em/process_watch'
+require 'em/tick_loop'
 
 require 'shellwords'
 require 'thread'
@@ -189,7 +128,7 @@ module EventMachine
   end
   @next_tick_mutex = Mutex.new
   @reactor_running = false
-  @next_tick_queue = nil
+  @next_tick_queue = []
   @threadpool = nil
   
 
@@ -266,15 +205,21 @@ module EventMachine
             @threadpool.each { |t| t.exit }
             @threadpool.each do |t|
               next unless t.alive?
-              # ruby 1.9 has no kill!
-              t.respond_to?(:kill!) ? t.kill! : t.kill
+              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
           end
 
-          @next_tick_queue = nil
+          @next_tick_queue = []
         end
         @reactor_running = false
         @reactor_thread = nil
@@ -989,11 +934,10 @@ module EventMachine
       cback.call result if cback
     end
 
-    jobs = @next_tick_mutex.synchronize do
+    @next_tick_mutex.synchronize do
       jobs, @next_tick_queue = @next_tick_queue, []
       jobs
-    end
-    jobs.each { |j| j.call }
+    end.each { |j| j.call }
   end
 
 
@@ -1055,6 +999,7 @@ module EventMachine
   def self.spawn_threadpool # :nodoc:
     until @threadpool.size == @threadpool_size.to_i
       thread = Thread.new do
+        Thread.current.abort_on_exception = true
         while true
           op, cback = *@threadqueue.pop
           result = op.call
@@ -1092,7 +1037,7 @@ module EventMachine
   def self.next_tick pr=nil, &block
     raise ArgumentError, "no proc or block given" unless ((pr && pr.respond_to?(:call)) or block)
     @next_tick_mutex.synchronize do
-      (@next_tick_queue ||= []) << ( pr || block )
+      @next_tick_queue << ( pr || block )
     end
     signal_loopbreak if reactor_running?
   end
@@ -1369,8 +1314,8 @@ module EventMachine
   #  EM.run {
   #    EM.start_server("127.0.0.1", 8080, ProxyServer)
   #  }
-  def self.enable_proxy(from, to, bufsize=0)
-    EM::start_proxy(from.signature, to.signature, bufsize)
+  def self.enable_proxy(from, to, bufsize=0, length=0)
+    EM::start_proxy(from.signature, to.signature, bufsize, length)
   end
 
   # disable_proxy takes just one argument, a Connection that has proxying enabled via enable_proxy.
@@ -1422,7 +1367,12 @@ module EventMachine
       elsif c = @acceptors.delete( conn_binding )
         # no-op
       else
-        raise ConnectionNotBound, "recieved ConnectionUnbound for an unknown signature: #{conn_binding}"
+        if $! # Bubble user generated errors.
+          @wrapped_exception = $!
+          EM.stop
+        else
+          raise ConnectionNotBound, "recieved ConnectionUnbound for an unknown signature: #{conn_binding}"
+        end
       end
     elsif opcode == ConnectionAccepted
       accep,args,blk = @acceptors[conn_binding]
@@ -1431,12 +1381,12 @@ module EventMachine
       @conns[data] = c
       blk and blk.call(c)
       c # (needed?)
-    elsif opcode == ConnectionCompleted
-      c = @conns[conn_binding] or raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
-      c.connection_completed
     ##
     # The remaining code is a fallback for the pure ruby and java reactors.
     # In the C++ reactor, these events are handled in the C event_callback() in rubymain.cpp
+    elsif opcode == ConnectionCompleted
+      c = @conns[conn_binding] or raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
+      c.connection_completed
     elsif opcode == TimerFired
       t = @timers.delete( data )
       return if t == false # timer cancelled
@@ -1572,7 +1522,11 @@ module EventMachine
       raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
       handler
     elsif handler
-      Class.new(klass){ include handler }
+      begin
+        handler::EM_CONNECTION_CLASS
+      rescue NameError
+        handler::const_set(:EM_CONNECTION_CLASS, Class.new(klass) {include handler})
+      end
     else
       klass
     end

data/lib/jeventmachine.rb

@@ -70,6 +70,7 @@ module EventMachine
   SslHandshakeCompleted = 108
 
   # Exceptions that are defined in rubymain.cpp
+  class ConnectionError < RuntimeError; end
   class ConnectionNotBound < RuntimeError; end
   class UnknownTimerFired < RuntimeError; end
   class Unsupported < RuntimeError; end

data/tests/test_attach.rb

@@ -46,11 +46,21 @@ class TestAttach < Test::Unit::TestCase
     def unbind
       EM.next_tick do
         $sock.write("def\n")
-        EM.add_timer(0.5){ EM.stop }
+        EM.add_timer(0.1){ EM.stop }
       end
     end
   end
 
+  def setup
+    $read, $write, $sock, $r, $w, $fd, $sock, $before, $after = nil
+  end
+
+  def teardown
+    [$read, $write, $sock, $r, $w, $fd, $sock, $before, $after].each do |io|
+      io.close rescue nil
+    end
+  end
+
   def test_attach
     EM.run{
       EM.start_server Host, Port, EchoServer
@@ -88,8 +98,8 @@ class TestAttach < Test::Unit::TestCase
   def test_set_readable
     EM.run{
       $r, $w = IO.pipe
-      c = EM.watch $r, PipeWatch do |c|
-        c.notify_readable = false
+      c = EM.watch $r, PipeWatch do |con|
+        con.notify_readable = false
       end
 
       EM.next_tick{

data/tests/test_basic.rb

@@ -30,44 +30,17 @@ require 'socket'
 require 'test/unit'
 
 class TestBasic < Test::Unit::TestCase
-
-  def setup
-    assert(!EM.reactor_running?)
-  end
-
-  def teardown
-    assert(!EM.reactor_running?)
-  end
-
-  #-------------------------------------
-
-  def test_libtype
-    lt = EventMachine.library_type
-    em_lib = (ENV["EVENTMACHINE_LIBRARY"] || $eventmachine_library || :xxx).to_sym
-
-    # Running from test runner, under jruby.
-    if RUBY_PLATFORM == 'java'
-      unless em_lib == :pure_ruby
-        assert_equal( :java, lt )
-        return
-      end
-    end
-
-    case em_lib
-    when :pure_ruby
-      assert_equal( :pure_ruby, lt )
-    when :extension
-      assert_equal( :extension, lt )
-    when :java
-      assert_equal( :java, lt )
-    else
-      # Running from jruby as a standalone test.
-      if RUBY_PLATFORM == 'java'
-        assert_equal( :java, lt )
-      else
-        assert_equal( :extension, lt )
-      end
-    end
+  def test_connection_class_cache
+    mod = Module.new
+    a, b = nil, nil
+    EM.run {
+      EM.start_server '127.0.0.1', 9999, mod
+      a = EM.connect '127.0.0.1', 9999, mod
+      b = EM.connect '127.0.0.1', 9999, mod
+      EM.stop
+    }
+    assert_equal a.class, b.class
+    assert_kind_of EM::Connection, a
   end
 
   #-------------------------------------
@@ -123,20 +96,11 @@ class TestBasic < Test::Unit::TestCase
     assert !EM.reactor_running?
   end
 
-
-  #--------------------------------------
-
-  # TODO! This is an unfinished edge case.
-  # EM mishandles uncaught Ruby exceptions that fire from within #unbind handlers.
-  # A uncaught Ruby exception results in a call to EM::release_machine (which is in an ensure
-  # block in EM::run). But if EM is processing an unbind request, the release_machine call
-  # will cause a segmentation fault.
-  #
-
   TestHost = "127.0.0.1"
   TestPort = 9070
 
   class UnbindError < EM::Connection
+    ERR = Class.new(StandardError)
     def initialize *args
       super
     end
@@ -144,12 +108,12 @@ class TestBasic < Test::Unit::TestCase
       close_connection_after_writing
     end
     def unbind
-      raise "Blooey"
+      raise ERR
     end
   end
 
-  def xxx_test_unbind_error
-    assert_raises( RuntimeError ) {
+  def test_unbind_error
+    assert_raises( UnbindError::ERR ) {
       EM.run {
         EM.start_server TestHost, TestPort
         EM.connect TestHost, TestPort, UnbindError
@@ -157,47 +121,6 @@ class TestBasic < Test::Unit::TestCase
     }
   end
 
-  #------------------------------------
-  #
-  # TODO. This is an unfinished bug fix.
-  # This case was originally reported by Dan Aquino. If you throw a Ruby exception
-  # in a post_init handler, it gets rethrown as a confusing reactor exception.
-  # The problem is in eventmachine.rb, which calls post_init within the private
-  # initialize method of the EM::Connection class. This happens in both the EM::connect
-  # method and in the code that responds to connection-accepted events.
-  # What happens is that we instantiate the new connection object, which calls
-  # initialize, and then after initialize returns, we stick the new connection object
-  # into EM's @conns hashtable.
-  # But the problem is that Connection::initialize calls #post_init before it returns,
-  # and this may be user-written code that may throw an uncaught Ruby exception.
-  # If that happens, the reactor will abort, and it will then try to run down open
-  # connections. Because @conns never got a chance to properly reflect the new connection
-  # (because initialize never returned), we throw a ConnectionNotBound error
-  # (eventmachine.rb line 1080).
-  # When the bug is fixed, activate this test case.
-  #
-
-  class PostInitError < EM::Connection
-    def post_init
-      aaa bbb # should produce a Ruby exception
-    end
-  end
-  # This test causes issues, the machine becomes unreleasable after 
-  # release_machine suffers an exception in event_callback.
-  def xxx_test_post_init_error
-    assert_raises( EventMachine::ConnectionNotBound ) {
-      EM.run {
-        EM::Timer.new(1) {EM.stop}
-        EM.start_server TestHost, TestPort
-        EM.connect TestHost, TestPort, PostInitError
-      }
-    }
-    EM.run {
-      EM.stop
-    }
-    assert !EM.reactor_running?
-  end
-
   module BrsTestSrv
     def receive_data data
       $received << data
@@ -213,6 +136,15 @@ class TestBasic < Test::Unit::TestCase
     end
   end
 
+  def setup_timeout(timeout = 4)
+    EM.schedule {
+      start_time = EM.current_time
+      EM.add_periodic_timer(0.01) {
+        raise "timeout" if EM.current_time - start_time >= timeout
+      }
+    }
+  end
+
   # From ticket #50
   def test_byte_range_send
     $received = ''
@@ -221,7 +153,7 @@ class TestBasic < Test::Unit::TestCase
       EM::start_server TestHost, TestPort, BrsTestSrv
       EM::connect TestHost, TestPort, BrsTestCli
 
-      EM::add_timer(0.5) { assert(false, 'test timed out'); EM.stop; Kernel.warn "test timed out!" }
+      setup_timeout
     }
     assert_equal($sent, $received)
   end
@@ -280,5 +212,38 @@ class TestBasic < Test::Unit::TestCase
     }
     assert_equal(interval, $interval)
   end
-end
-
+  
+  module PostInitRaiser
+    ERR = Class.new(StandardError)
+    def post_init
+      raise ERR
+    end
+  end
+  
+  def test_bubble_errors_from_post_init
+    localhost, port = '127.0.0.1', 9000
+    assert_raises(PostInitRaiser::ERR) do
+      EM.run do
+        EM.start_server localhost, port
+        EM.connect localhost, port, PostInitRaiser
+      end
+    end
+  end
+  
+  module InitializeRaiser
+    ERR = Class.new(StandardError)
+    def initialize
+      raise ERR
+    end
+  end
+  
+  def test_bubble_errors_from_initialize
+    localhost, port = '127.0.0.1', 9000
+    assert_raises(InitializeRaiser::ERR) do
+      EM.run do
+        EM.start_server localhost, port
+        EM.connect localhost, port, InitializeRaiser
+      end
+    end
+  end
+end