eventmachine 0.9.0 → 0.10.0

data/lib/eventmachine_version.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine_version.rb 536 2007-09-16 23:55:03Z blackhedd $
+# $Id: eventmachine_version.rb 608 2007-12-09 21:04:39Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -25,7 +25,7 @@
 
 module EventMachine
 
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 
 end
 

data/lib/pr_eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: pr_eventmachine.rb 319 2007-05-22 22:11:18Z blackhedd $
+# $Id: pr_eventmachine.rb 604 2007-12-06 12:31:39Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -32,6 +32,7 @@ require 'singleton'
 require 'forwardable'
 require 'socket'
 require 'fcntl'
+require 'set'
 
 
 module EventMachine
@@ -99,6 +100,23 @@ module EventMachine
       s.uuid
     end
 
+    # #stop_tcp_server
+    def stop_tcp_server sig
+      s = Reactor.instance.get_selectable(sig)
+      s.schedule_close
+    end
+
+    # #start_unix_server
+    def start_unix_server chain
+      (s = EvmaUNIXServer.start_server chain) or raise "no acceptor"
+      s.uuid
+    end
+
+    # #connect_unix_server
+    def connect_unix_server chain
+      EvmaUNIXClient.connect(chain).uuid
+    end
+
     # #signal_loopbreak
     def signal_loopbreak
       Reactor.instance.signal_loopbreak
@@ -129,6 +147,54 @@ module EventMachine
       Reactor.instance.set_timer_quantum(( 1.0 * interval) / 1000.0)
     end
 
+    # #epoll is a harmless no-op in the pure-Ruby implementation. This is intended to ensure
+    # that user code behaves properly across different EM implementations.
+    def epoll
+    end
+
+    # #set_rlimit_nofile is a no-op in the pure-Ruby implementation. We simply return Ruby's built-in
+    # per-process file-descriptor limit.
+    def set_rlimit_nofile n
+      1024
+    end
+
+    # #set_max_timer_count is a harmless no-op in pure Ruby, which doesn't have a built-in limit
+    # on the number of available timers.
+    def set_max_timer_count n
+    end
+
+    # #send_file_data
+    def send_file_data sig, filename
+      sz = File.size(filename)
+      raise "file too large" if sz > 32*1024
+      data =
+      begin
+        File.read filename
+      rescue
+        ""
+      end
+      send_data sig, data, data.length
+    end
+
+    # #get_outbound_data_size
+    #
+    def get_outbound_data_size sig
+      r = Reactor.instance.get_selectable( sig ) or raise "unknown get_outbound_data_size target"
+      r.get_outbound_data_size
+    end
+
+    # #read_keyboard
+    #
+    def read_keyboard
+      EvmaKeyboard.open.uuid
+    end
+
+    # #set_comm_inactivity_timeout
+    #
+    def set_comm_inactivity_timeout sig, tm
+      r = Reactor.instance.get_selectable( sig ) or raise "unknown set_comm_inactivity_timeout target"
+      r.set_inactivity_timeout tm
+    end
   end
 
 end
@@ -144,6 +210,16 @@ end
 
 #-----------------------------------------------------------------
 
+module EventMachine
+  class Connection
+    def get_outbound_data_size
+      EventMachine::get_outbound_data_size @signature
+    end
+  end
+end
+
+#-----------------------------------------------------------------
+
 module EventMachine
 
   # Factored out so we can substitute other implementations
@@ -171,11 +247,11 @@ end
 module EventMachine
 
   TimerFired = 100
-	ConnectionData = 101
-	ConnectionUnbound = 102
-	ConnectionAccepted = 103
-	ConnectionCompleted = 104
-	LoopbreakSignalled = 105
+  ConnectionData = 101
+  ConnectionUnbound = 102
+  ConnectionAccepted = 103
+  ConnectionCompleted = 104
+  LoopbreakSignalled = 105
 
 end
 
@@ -185,14 +261,21 @@ module EventMachine
 class Reactor
   include Singleton
 
+  HeartbeatInterval = 2
+
+  attr_reader :current_loop_time
+
   def initialize
     initialize_for_run
   end
 
+  #--
+  # Replaced original implementation 05Dec07, was way too slow because of the sort.
   def install_oneshot_timer interval
     uuid = UuidGenerator::generate
-    @timers << [Time.now + interval, uuid]
-    @timers.sort! {|a,b| a.first <=> b.first}
+    #@timers << [Time.now + interval, uuid]
+    #@timers.sort! {|a,b| a.first <=> b.first}
+    @timers.add([Time.now + interval, uuid])
     uuid
   end
 
@@ -202,8 +285,10 @@ class Reactor
     @running = false
     @stop_scheduled = false
     @selectables ||= {}; @selectables.clear
-    @timers = []
-    set_timer_quantum(0.5)
+    @timers = SortedSet.new # []
+    set_timer_quantum(0.1)
+    @current_loop_time = Time.now
+    @next_heartbeat = @current_loop_time + HeartbeatInterval
   end
 
   def add_selectable io
@@ -217,27 +302,49 @@ class Reactor
   def run
     raise Error.new( "already running" ) if @running
     @running = true
-    open_loopbreaker
 
-    loop {
-      break if @stop_scheduled
-      run_timers
-      break if @stop_scheduled
-      crank_selectables
-    }
+    begin
+      open_loopbreaker
 
-    close_loopbreaker
-    @selectables.each {|k, io| io.close}
-    @selectables.clear
+      loop {
+	@current_loop_time = Time.now
+
+        break if @stop_scheduled
+        run_timers
+        break if @stop_scheduled
+        crank_selectables
+        break if @stop_scheduled
+        run_heartbeats
+      }
+    ensure
+      close_loopbreaker
+      @selectables.each {|k, io| io.close}
+      @selectables.clear
+
+      @running = false
+    end
 
-    @running = false
   end
 
   def run_timers
-    now = Time.now
-    while @timers.length > 0 and @timers.first.first <= now
-      t = @timers.shift
-      EventMachine::event_callback "", TimerFired, t.last
+    @timers.each {|t|
+      if t.first <= @current_loop_time
+        @timers.delete t
+	EventMachine::event_callback "", TimerFired, t.last
+      else
+        break
+      end
+    }
+    #while @timers.length > 0 and @timers.first.first <= now
+    #  t = @timers.shift
+    #  EventMachine::event_callback "", TimerFired, t.last
+    #end
+  end
+
+  def run_heartbeats
+    if @next_heartbeat <= @current_loop_time
+      @next_heartbeat = @current_loop_time + HeartbeatInterval
+      @selectables.each {|k,io| io.heartbeat}
     end
   end
 
@@ -304,6 +411,9 @@ class IO
   def_delegator :@my_selectable, :schedule_close
   def_delegator :@my_selectable, :get_peername
   def_delegator :@my_selectable, :send_datagram
+  def_delegator :@my_selectable, :get_outbound_data_size
+  def_delegator :@my_selectable, :set_inactivity_timeout
+  def_delegator :@my_selectable, :heartbeat
 end
 
 #--------------------------------------------------------------
@@ -316,6 +426,7 @@ module EventMachine
     def initialize io
       @uuid = UuidGenerator.generate
       @io = io
+      @last_activity = Reactor.instance.current_loop_time
 
       m = @io.fcntl(Fcntl::F_GETFL, 0)
       @io.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK | m)
@@ -344,6 +455,12 @@ module EventMachine
       nil
     end
 
+    def set_inactivity_timeout tm
+      @inactivity_timeout = tm
+    end
+
+    def heartbeat
+    end
   end
 
 end
@@ -384,9 +501,12 @@ module EventMachine
     # Proper nonblocking I/O was added to Ruby 1.8.4 in May 2006.
     # If we have it, then we can read multiple times safely to improve
     # performance.
+    # The last-activity clock ASSUMES that we only come here when we
+    # have selected readable.
     # TODO, coalesce multiple reads into a single event.
     # TODO, do the function check somewhere else and cache it.
     def eventable_read
+      @last_activity = Reactor.instance.current_loop_time
       begin
         if io.respond_to?(:read_nonblock)
           10.times {
@@ -399,7 +519,7 @@ module EventMachine
         end
       rescue Errno::EAGAIN
         # no-op
-      rescue Errno::ECONNRESET, EOFError
+      rescue Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError
         @close_scheduled = true
         EventMachine::event_callback uuid, ConnectionUnbound, nil
       end
@@ -416,8 +536,11 @@ module EventMachine
     # one busy connection could hog output buffers and slow down other
     # connections. Also we should coalesce small writes.
     # URGENT TODO: Coalesce small writes. They are a performance killer.
+    # The last-activity recorder ASSUMES we'll only come here if we've
+    # selected writable.
     def eventable_write
       # coalesce the outbound array here, perhaps
+      @last_activity = Reactor.instance.current_loop_time
       while data = @outbound_q.shift do
         begin
           data = data.to_s
@@ -433,7 +556,7 @@ module EventMachine
           end
         rescue Errno::EAGAIN
           @outbound_q.unshift data
-        rescue EOFError, Errno::ECONNRESET
+        rescue EOFError, Errno::ECONNRESET, Errno::ECONNREFUSED
           @close_scheduled = true
           @outbound_q.clear
         end
@@ -467,6 +590,16 @@ module EventMachine
       io.getpeername
     end
 
+    # #get_outbound_data_size
+    def get_outbound_data_size
+      @outbound_q.inject(0) {|memo,obj| memo += (obj || "").length}
+    end
+
+    def heartbeat
+      if @inactivity_timeout and (@last_activity + @inactivity_timeout) < Reactor.instance.current_loop_time
+        schedule_close true
+      end
+    end
   end
 
 
@@ -509,7 +642,88 @@ module EventMachine
     def eventable_write
       if @pending
         @pending = false
-        EventMachine::event_callback uuid, ConnectionCompleted, ""
+	if 0 == io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first
+          EventMachine::event_callback uuid, ConnectionCompleted, ""
+	end
+      else
+        super
+      end
+    end
+
+
+
+  end
+end
+
+#--------------------------------------------------------------
+
+
+
+module EventMachine
+  class EvmaKeyboard < StreamObject
+
+    def self.open
+      EvmaKeyboard.new STDIN
+    end
+
+
+    def initialize io
+      super
+    end
+
+
+    def select_for_writing?
+      false
+    end
+
+    def select_for_reading?
+      true
+    end
+
+
+  end
+end
+
+
+#--------------------------------------------------------------
+
+
+
+module EventMachine
+  class EvmaUNIXClient < StreamObject
+
+    def self.connect chain
+      sd = Socket.new( Socket::AF_LOCAL, Socket::SOCK_STREAM, 0 )
+      begin
+        # TODO, this assumes a current Ruby snapshot.
+        # We need to degrade to a nonblocking connect otherwise.
+        sd.connect_nonblock( Socket.pack_sockaddr_un( chain ))
+      rescue Errno::EINPROGRESS
+      end
+      EvmaUNIXClient.new sd
+    end
+
+
+    def initialize io
+      super
+      @pending = true
+    end
+
+
+    def select_for_writing?
+      @pending ? true : super
+    end
+
+    def select_for_reading?
+      @pending ? false : super
+    end
+
+    def eventable_write
+      if @pending
+        @pending = false
+	if 0 == io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first
+          EventMachine::event_callback uuid, ConnectionCompleted, ""
+	end
       else
         super
       end
@@ -526,6 +740,8 @@ end
 module EventMachine
   class EvmaTCPServer < Selectable
 
+    # TODO, refactor and unify with EvmaUNIXServer.
+
     class << self
       # Versions of ruby 1.8.4 later than May 26 2006 will work properly
       # with an object of type TCPServer. Prior versions won't so we
@@ -564,6 +780,66 @@ module EventMachine
       end
     end
 
+    #--
+    #
+    def schedule_close
+      @close_scheduled = true
+    end
+
+  end
+end
+
+
+#--------------------------------------------------------------
+
+module EventMachine
+  class EvmaUNIXServer < Selectable
+
+    # TODO, refactor and unify with EvmaTCPServer.
+
+    class << self
+      # Versions of ruby 1.8.4 later than May 26 2006 will work properly
+      # with an object of type TCPServer. Prior versions won't so we
+      # play it safe and just build a socket.
+      #
+      def start_server chain
+        sd = Socket.new( Socket::AF_LOCAL, Socket::SOCK_STREAM, 0 )
+        sd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true )
+        sd.bind( Socket.pack_sockaddr_un( chain ))
+        sd.listen( 50 ) # 5 is what you see in all the books. Ain't enough.
+        EvmaUNIXServer.new sd
+      end
+    end
+
+    def initialize io
+      super io
+    end
+
+
+    def select_for_reading?
+      true
+    end
+
+    #--
+    # accept_nonblock returns an array consisting of the accepted
+    # socket and a sockaddr_in which names the peer.
+    # Don't accept more than 10 at a time.
+    def eventable_read
+      begin
+        10.times {
+          descriptor,peername = io.accept_nonblock
+          sd = StreamObject.new descriptor
+          EventMachine::event_callback uuid, ConnectionAccepted, sd.uuid
+        }
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+      end
+    end
+
+    #--
+    #
+    def schedule_close
+      @close_scheduled = true
+    end
 
   end
 end
@@ -623,6 +899,11 @@ module EventMachine
       true
     end
 
+    # #get_outbound_data_size
+    def get_outbound_data_size
+      @outbound_q.inject(0) {|memo,obj| memo += (obj || "").length}
+    end
+
 
   end