eventmachine 0.12.8-x86-mswin32-60 → 0.12.10-x86-mswin32-60

data/lib/em/protocols/socks4.rb

@@ -0,0 +1,66 @@
+module EventMachine
+  module Protocols
+    # Basic SOCKS v4 client implementation
+    #
+    # Use as you would any regular connection:
+    #
+    # class MyConn < EM::P::Socks4
+    #   def post_init
+    #     send_data("sup")
+    #   end
+    #
+    #   def receive_data(data)
+    #     send_data("you said: #{data}")
+    #   end
+    # end
+    #
+    # EM.connect socks_host, socks_port, MyConn, host, port
+    #
+    class Socks4 < Connection
+      def initialize(host, port)
+        @host = Socket.gethostbyname(host).last
+        @port = port
+        @socks_error_code = nil
+        @buffer = ''
+        setup_methods
+      end
+
+      def setup_methods
+        class << self
+          def post_init; socks_post_init; end
+          def receive_data(*a); socks_receive_data(*a); end
+        end
+      end
+
+      def restore_methods
+        class << self
+          remove_method :post_init
+          remove_method :receive_data
+        end
+      end
+
+      def socks_post_init
+        header = [4, 1, @port, @host, 0].flatten.pack("CCnA4C")
+        send_data(header)
+      end
+
+      def socks_receive_data(data)
+        @buffer << data
+        return  if @buffer.size < 8
+
+        header_resp = @buffer.slice! 0, 8
+        _, r = header_resp.unpack("cc")
+        if r != 90
+          @socks_error_code = r
+          close_connection
+          return
+        end
+
+        restore_methods
+
+        post_init
+        receive_data(@buffer)  unless @buffer.empty?
+      end
+    end
+  end
+end

data/lib/em/queue.rb

@@ -1,61 +1,61 @@
-module EventMachine
-  # A cross thread, reactor scheduled, linear queue.
-  #
-  # This class provides a simple "Queue" like abstraction on top of the reactor
-  # scheduler. It services two primary purposes:
-  # * API sugar for stateful protocols
-  # * Pushing processing onto the same thread as the reactor
-  #
-  # See examples/ex_queue.rb for a detailed example.
-  #
-  #  q = EM::Queue.new
-  #  q.push('one', 'two', 'three')
-  #  3.times do
-  #    q.pop{ |msg| puts(msg) }
-  #  end
-  #
-  class Queue
-    # Create a new queue
-    def initialize
-      @items = []
-      @popq  = []
-    end
-
-    # Pop items off the queue, running the block on the reactor thread. The pop
-    # will not happen immediately, but at some point in the future, either in 
-    # the next tick, if the queue has data, or when the queue is populated.
-    def pop(*a, &b)
-      cb = EM::Callback(*a, &b)
-      EM.schedule do
-        if @items.empty?
-          @popq << cb
-        else
-          cb.call @items.shift
-        end
-      end
-      nil # Always returns nil
-    end
-
-    # Push items onto the queue in the reactor thread. The items will not appear
-    # in the queue immediately, but will be scheduled for addition during the 
-    # next reactor tick.
-    def push(*items)
-      EM.schedule do
-        @items.concat items
-        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
-      end
-    end
-
-    # N.B. This is a peek, it's not thread safe, and may only tend toward 
-    # accuracy.
-    def empty?
-      @items.empty?
-    end
-
-    # N.B. This is a peek, it's not thread safe, and may only tend toward 
-    # accuracy.
-    def size
-      @items.size
-    end
-  end
+module EventMachine
+  # A cross thread, reactor scheduled, linear queue.
+  #
+  # This class provides a simple "Queue" like abstraction on top of the reactor
+  # scheduler. It services two primary purposes:
+  # * API sugar for stateful protocols
+  # * Pushing processing onto the same thread as the reactor
+  #
+  # See examples/ex_queue.rb for a detailed example.
+  #
+  #  q = EM::Queue.new
+  #  q.push('one', 'two', 'three')
+  #  3.times do
+  #    q.pop{ |msg| puts(msg) }
+  #  end
+  #
+  class Queue
+    # Create a new queue
+    def initialize
+      @items = []
+      @popq  = []
+    end
+
+    # Pop items off the queue, running the block on the reactor thread. The pop
+    # will not happen immediately, but at some point in the future, either in 
+    # the next tick, if the queue has data, or when the queue is populated.
+    def pop(*a, &b)
+      cb = EM::Callback(*a, &b)
+      EM.schedule do
+        if @items.empty?
+          @popq << cb
+        else
+          cb.call @items.shift
+        end
+      end
+      nil # Always returns nil
+    end
+
+    # Push items onto the queue in the reactor thread. The items will not appear
+    # in the queue immediately, but will be scheduled for addition during the 
+    # next reactor tick.
+    def push(*items)
+      EM.schedule do
+        @items.push(*items)
+        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+      end
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def empty?
+      @items.empty?
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def size
+      @items.size
+    end
+  end
 end

data/lib/em/timers.rb

@@ -1,55 +1,56 @@
-module EventMachine
-  # Creates a one-time timer
-  #
-  #  timer = EventMachine::Timer.new(5) do
-  #    # this will never fire because we cancel it
-  #  end
-  #  timer.cancel
-  #
-  class Timer
-    # Create a new timer that fires after a given number of seconds
-    def initialize interval, callback=nil, &block
-      @signature = EventMachine::add_timer(interval, callback || block)
-    end
-
-    # Cancel the timer
-    def cancel
-      EventMachine.send :cancel_timer, @signature
-    end
-  end
-
-  # Creates a periodic timer
-  #
-  #  n = 0
-  #  timer = EventMachine::PeriodicTimer.new(5) do
-  #    puts "the time is #{Time.now}"
-  #    timer.cancel if (n+=1) > 5
-  #  end
-  #
-  class PeriodicTimer
-    # Create a new periodic timer that executes every interval seconds
-    def initialize interval, callback=nil, &block
-      @interval = interval
-      @code = callback || block
-      schedule
-    end
-
-    # Cancel the periodic timer
-    def cancel
-      @cancelled = true
-    end
-
-    # Fire the timer every interval seconds
-    attr_accessor :interval
-
-    def schedule # :nodoc:
-      EventMachine::add_timer @interval, proc {self.fire}
-    end
-    def fire # :nodoc:
-      unless @cancelled
-        @code.call
-        schedule
-      end
-    end
-  end
-end
+module EventMachine
+  # Creates a one-time timer
+  #
+  #  timer = EventMachine::Timer.new(5) do
+  #    # this will never fire because we cancel it
+  #  end
+  #  timer.cancel
+  #
+  class Timer
+    # Create a new timer that fires after a given number of seconds
+    def initialize interval, callback=nil, &block
+      @signature = EventMachine::add_timer(interval, callback || block)
+    end
+
+    # Cancel the timer
+    def cancel
+      EventMachine.send :cancel_timer, @signature
+    end
+  end
+
+  # Creates a periodic timer
+  #
+  #  n = 0
+  #  timer = EventMachine::PeriodicTimer.new(5) do
+  #    puts "the time is #{Time.now}"
+  #    timer.cancel if (n+=1) > 5
+  #  end
+  #
+  class PeriodicTimer
+    # Create a new periodic timer that executes every interval seconds
+    def initialize interval, callback=nil, &block
+      @interval = interval
+      @code = callback || block
+      @cancelled = false
+      schedule
+    end
+
+    # Cancel the periodic timer
+    def cancel
+      @cancelled = true
+    end
+
+    # Fire the timer every interval seconds
+    attr_accessor :interval
+
+    def schedule # :nodoc:
+      EventMachine::add_timer @interval, method(:fire)
+    end
+    def fire # :nodoc:
+      unless @cancelled
+        @code.call
+        schedule
+      end
+    end
+  end
+end

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "0.12.8"
+  VERSION = "0.12.10"
 end

data/lib/eventmachine.rb

@@ -90,6 +90,7 @@ require 'em/file_watch'
 require 'em/process_watch'
 
 require 'shellwords'
+require 'thread'
 
 # == Introduction
 # EventMachine provides a fast, lightweight framework for implementing
@@ -180,6 +181,18 @@ require 'shellwords'
 # Interesting thought.
 #
 module EventMachine
+  class <<self
+    # Exposed to allow joining on the thread, when run in a multithreaded
+    # environment. Performing other actions on the thread has undefined
+    # semantics.
+    attr_reader :reactor_thread
+  end
+  @next_tick_mutex = Mutex.new
+  @reactor_running = false
+  @next_tick_queue = nil
+  @threadpool = nil
+  
+
   # EventMachine::run initializes and runs an event loop.
   # This method only returns if user-callback code calls stop_event_loop.
   # Use the supplied block to define your clients and servers.
@@ -231,6 +244,7 @@ module EventMachine
       @acceptors = {}
       @timers = {}
       @wrapped_exception = nil
+      @next_tick_queue ||= []
       begin
         @reactor_running = true
         initialize_event_machine
@@ -241,26 +255,31 @@ module EventMachine
         @reactor_thread = Thread.current
         run_machine
       ensure
+        until @tails.empty?
+          @tails.pop.call
+        end
+
         begin
           release_machine
         ensure
           if @threadpool
             @threadpool.each { |t| t.exit }
-            @threadpool.each { |t| t.kill! if t.alive? }
+            @threadpool.each do |t|
+              next unless t.alive?
+              # ruby 1.9 has no kill!
+              t.respond_to?(:kill!) ? t.kill! : t.kill
+            end
             @threadqueue = nil
             @resultqueue = nil
+            @threadpool = nil
           end
-          @threadpool = nil
+
           @next_tick_queue = nil
         end
         @reactor_running = false
         @reactor_thread = nil
       end
 
-      until @tails.empty?
-        @tails.pop.call
-      end
-
       raise @wrapped_exception if @wrapped_exception
     end
   end
@@ -381,19 +400,18 @@ module EventMachine
   def self.add_periodic_timer *args, &block
     interval = args.shift
     code = args.shift || block
-    if code
-      block_1 = proc {
-        code.call
-        EventMachine::add_periodic_timer interval, code
-      }
-      add_timer interval, block_1
-    end
+
+    EventMachine::PeriodicTimer.new(interval, code)
   end
 
   # Cancel a timer using its signature. You can also use EventMachine::Timer#cancel
   #
-  def self.cancel_timer signature
-    @timers[signature] = false if @timers.has_key?(signature)
+  def self.cancel_timer timer_or_sig
+    if timer_or_sig.respond_to? :cancel
+      timer_or_sig.cancel
+    else
+      @timers[timer_or_sig] = false if @timers.has_key?(timer_or_sig)
+    end
   end
 
 
@@ -548,18 +566,7 @@ module EventMachine
       port = nil
     end if port
 
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})" 
-    end
+    klass = klass_from_handler(Connection, handler, *args)
 
     s = if port
           start_tcp_server server, port
@@ -614,11 +621,13 @@ module EventMachine
   #    def post_init
   #      send_data "GET / HTTP/1.1\r\nHost: _\r\n\r\n"
   #      @data = ""
+  #      @parsed = false
   #    end
   #  
   #    def receive_data data
   #      @data << data
-  #      if  @data =~ /[\n][\r]*[\n]/m
+  #      if !@parsed and @data =~ /[\n][\r]*[\n]/m
+  #        @parsed = true
   #        puts "RECEIVED HTTP HEADER:"
   #        $`.each {|line| puts ">>> #{line}" }
   #  
@@ -679,6 +688,12 @@ module EventMachine
   # to have them behave differently with respect to post_init
   # if at all possible.
   #
+  def self.connect server, port=nil, handler=nil, *args, &blk
+    bind_connect nil, nil, server, port, handler, *args, &blk
+  end
+
+  # EventMachine::bind_connect is like EventMachine::connect, but allows for a local address/port
+  # to bind the connection to.
   def self.bind_connect bind_addr, bind_port, server, port=nil, handler=nil, *args
     begin
       port = Integer(port)
@@ -690,22 +705,11 @@ module EventMachine
       port = nil
     end if port
 
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
-    end
+    klass = klass_from_handler(Connection, handler, *args)
 
     s = if port
           if bind_addr
-            bind_connect_server bind_addr, bind_port, server, port
+            bind_connect_server bind_addr, bind_port.to_i, server, port
           else
             connect_server server, port
           end
@@ -719,30 +723,25 @@ module EventMachine
     c
   end
 
-  def self.connect server, port=nil, handler=nil, *args, &blk
-    bind_connect nil, nil, server, port, handler, *args, &blk
-  end
-
-  # EventMachine::attach registers a given file descriptor or IO object with the eventloop
+  # EventMachine::watch registers a given file descriptor or IO object with the eventloop. The
+  # file descriptor will not be modified (it will remain blocking or non-blocking).
+  #
+  # The eventloop can be used to process readable and writable events on the file descriptor, using
+  # EventMachine::Connection#notify_readable= and EventMachine::Connection#notify_writable=
   #
-  # If the handler provided has the functions notify_readable or notify_writable defined,
-  # EventMachine will not read or write from the socket, and instead fire the corresponding
-  # callback on the handler.
+  # EventMachine::Connection#notify_readable? and EventMachine::Connection#notify_writable? can be used
+  # to check what events are enabled on the connection.
   #
   # To detach the file descriptor, use EventMachine::Connection#detach
   #
   # === Usage Example
   #
   #  module SimpleHttpClient
-  #    def initialize sock
-  #      @sock = sock
-  #    end
-  #
   #    def notify_readable
-  #      header = @sock.readline
+  #      header = @io.readline
   #
   #      if header == "\r\n"
-  #        # detach returns the file descriptor number (fd == @sock.fileno)
+  #        # detach returns the file descriptor number (fd == @io.fileno)
   #        fd = detach
   #      end
   #    rescue EOFError
@@ -752,7 +751,7 @@ module EventMachine
   #    def unbind
   #      EM.next_tick do
   #        # socket is detached from the eventloop, but still open
-  #        data = @sock.read
+  #        data = @io.read
   #      end
   #    end
   #  end
@@ -760,31 +759,45 @@ module EventMachine
   #  EM.run{
   #    $sock = TCPSocket.new('site.com', 80)
   #    $sock.write("GET / HTTP/1.0\r\n\r\n")
-  #    EM.attach $sock, SimpleHttpClient, $sock
+  #    conn = EM.watch $sock, SimpleHttpClient
+  #    conn.notify_readable = true
   #  }
   #
   #--
   # Thanks to Riham Aldakkak (eSpace Technologies) for the initial patch
-  def  EventMachine::attach io, handler=nil, *args
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
+  def EventMachine::watch io, handler=nil, *args, &blk
+    attach_io io, true, handler, *args, &blk
+  end
+
+  # Attaches an IO object or file descriptor to the eventloop as a regular connection.
+  # The file descriptor will be set as non-blocking, and EventMachine will process
+  # receive_data and send_data events on it as it would for any other connection.
+  #
+  # To watch a fd instead, use EventMachine::watch, which will not alter the state of the socket
+  # and fire notify_readable and notify_writable events instead.
+  def EventMachine::attach io, handler=nil, *args, &blk
+    attach_io io, false, handler, *args, &blk
+  end
+
+  def EventMachine::attach_io io, watch_mode, handler=nil, *args # :nodoc:
+    klass = klass_from_handler(Connection, handler, *args)
+
+    if !watch_mode and klass.public_instance_methods.any?{|m| [:notify_readable, :notify_writable].include? m.to_sym }
+      raise ArgumentError, "notify_readable/writable with EM.attach is not supported. Use EM.watch(io){ |c| c.notify_readable = true }"
     end
 
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    if io.respond_to?(:fileno)
+      fd = defined?(JRuby) ? JRuby.runtime.getDescriptorByFileno(io.fileno).getChannel : io.fileno
+    else
+      fd = io
     end
 
-    readmode  = klass.public_instance_methods.any?{|m| m.to_sym == :notify_readable }
-    writemode = klass.public_instance_methods.any?{|m| m.to_sym == :notify_writable }
+    s = attach_fd fd, watch_mode
+    c = klass.new s, *args
 
-    s = attach_fd io.respond_to?(:fileno) ? io.fileno : io, readmode, writemode
+    c.instance_variable_set(:@io, io)
+    c.instance_variable_set(:@fd, fd)
 
-    c = klass.new s, *args
     @conns[s] = c
     block_given? and yield c
     c
@@ -793,8 +806,6 @@ module EventMachine
 
   # Connect to a given host/port and re-use the provided EventMachine::Connection instance
   #--
-  # EXPERIMENTAL. DO NOT RELY ON THIS METHOD TO BE HERE IN THIS FORM, OR AT ALL.
-  # (03Nov06)
   # Observe, the test for already-connected FAILS if we call a reconnect inside post_init,
   # because we haven't set up the connection in @conns by that point.
   # RESIST THE TEMPTATION to "fix" this problem by redefining the behavior of post_init.
@@ -900,19 +911,7 @@ module EventMachine
   # out that this originally did not take a class but only a module.
   #
   def self.open_datagram_socket address, port, handler=nil, *args
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
-    end
-
+    klass = klass_from_handler(Connection, handler, *args)
     s = open_udp_socket address, port.to_i
     c = klass.new s, *args
     @conns[s] = c
@@ -990,26 +989,11 @@ module EventMachine
       cback.call result if cback
     end
 
-    @next_tick_queue ||= []
-    if (l = @next_tick_queue.length) > 0
-      l.times {|i| @next_tick_queue[i].call}
-      @next_tick_queue.slice!( 0...l )
+    jobs = @next_tick_mutex.synchronize do
+      jobs, @next_tick_queue = @next_tick_queue, []
+      jobs
     end
-
-=begin
-    (@next_tick_queue ||= []).length.times {
-      cback=@next_tick_queue.pop and cback.call
-    }
-=end
-=begin
-    if (@next_tick_queue ||= []) and @next_tick_queue.length > 0
-      ary = @next_tick_queue.dup
-      @next_tick_queue.clear
-      until ary.empty?
-        cback=ary.pop and cback.call
-      end
-    end
-=end
+    jobs.each { |j| j.call }
   end
 
 
@@ -1069,7 +1053,7 @@ module EventMachine
   end
 
   def self.spawn_threadpool # :nodoc:
-    until @threadpool.size == @threadpool_size
+    until @threadpool.size == @threadpool_size.to_i
       thread = Thread.new do
         while true
           op, cback = *@threadqueue.pop
@@ -1106,18 +1090,11 @@ module EventMachine
   # extremely expensive even if they're just sleeping.
   #
   def self.next_tick pr=nil, &block
-    raise "no argument or block given" unless ((pr && pr.respond_to?(:call)) or block)
-    (@next_tick_queue ||= []) << ( pr || block )
-    signal_loopbreak if reactor_running?
-=begin
-    (@next_tick_procs ||= []) << (pr || block)
-    if @next_tick_procs.length == 1
-      add_timer(0) {
-        @next_tick_procs.each {|t| t.call}
-        @next_tick_procs.clear
-      }
+    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 )
     end
-=end
+    signal_loopbreak if reactor_running?
   end
 
   # A wrapper over the setuid system call. Particularly useful when opening a network
@@ -1182,13 +1159,7 @@ module EventMachine
   # Perhaps misnamed since the underlying function uses socketpair and is full-duplex.
   #
   def self.popen cmd, handler=nil, *args
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
-
+    klass = klass_from_handler(Connection, handler, *args)
     w = Shellwords::shellwords( cmd )
     w.unshift( w.first ) if w.first
     s = invoke_popen( w )
@@ -1218,18 +1189,7 @@ module EventMachine
   #
   #
   def self.open_keyboard handler=nil, *args
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
-    end
+    klass = klass_from_handler(Connection, handler, *args)
 
     s = read_keyboard
     c = klass.new s, *args
@@ -1286,6 +1246,8 @@ module EventMachine
   #    end
   #  end
   #
+  #  EM.kqueue = true if EM.kqueue? # file watching requires kqueue on OSX
+  #
   #  EM.run {
   #    EM.watch_file("/tmp/foo", Handler)
   #  }
@@ -1299,18 +1261,7 @@ module EventMachine
   # Calling #path will always return the filename you originally used.
   #
   def self.watch_file(filename, handler=nil, *args)
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::FileWatch' unless FileWatch > handler
-      handler
-    else
-      Class.new( FileWatch ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
-    end
+    klass = klass_from_handler(FileWatch, handler, *args)
 
     s = EM::watch_filename(filename)
     c = klass.new s, *args
@@ -1341,18 +1292,7 @@ module EventMachine
   def self.watch_process(pid, handler=nil, *args)
     pid = pid.to_i
 
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::ProcessWatch' unless ProcessWatch > handler
-      handler
-    else
-      Class.new( ProcessWatch ) {handler and include handler}
-    end
-
-    arity = klass.instance_method(:initialize).arity
-    expected = arity >= 0 ? arity : -(arity + 1)
-    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
-    end
+    klass = klass_from_handler(ProcessWatch, handler, *args)
 
     s = EM::watch_pid(pid)
     c = klass.new s, *args
@@ -1429,8 +1369,8 @@ module EventMachine
   #  EM.run {
   #    EM.start_server("127.0.0.1", 8080, ProxyServer)
   #  }
-  def self.enable_proxy(from, to)
-    EM::start_proxy(from.signature, to.signature)
+  def self.enable_proxy(from, to, bufsize=0)
+    EM::start_proxy(from.signature, to.signature, bufsize)
   end
 
   # disable_proxy takes just one argument, a Connection that has proxying enabled via enable_proxy.
@@ -1495,7 +1435,8 @@ module EventMachine
       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 reactor. Usually these events are handled in the C event_callback() in rubymain.cpp
+    # 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 == TimerFired
       t = @timers.delete( data )
       return if t == false # timer cancelled
@@ -1616,12 +1557,7 @@ module EventMachine
   # This is a provisional implementation of a stream-oriented file access object.
   # We also experiment with wrapping up some better exception reporting.
   def self._open_file_for_writing filename, handler=nil # :nodoc:
-    klass = if (handler and handler.is_a?(Class))
-      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
-      handler
-    else
-      Class.new( Connection ) {handler and include handler}
-    end
+    klass = klass_from_handler(Connection, handler)
 
     s = _write_file filename
     c = klass.new s
@@ -1629,6 +1565,26 @@ module EventMachine
     block_given? and yield c
     c
   end
+
+  private
+  def self.klass_from_handler(klass = Connection, handler = nil, *args)
+    klass = if handler and handler.is_a?(Class)
+      raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
+      handler
+    elsif handler
+      Class.new(klass){ include handler }
+    else
+      klass
+    end
+
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    end
+
+    klass
+  end
 end # module EventMachine
 
 # Save everyone some typing.