eventmachine 0.12.10-x86-mswin32-60 → 1.0.0.beta.2-x86-mswin32-60

data/lib/em/channel.rb

@@ -35,7 +35,7 @@ module EventMachine
     # Add items to the channel, which are pushed out to all subscribers.
     def push(*items)
       items = items.dup
-      EM.schedule { @subs.values.each { |s| items.each { |i| s.call i } } }
+      EM.schedule { items.each { |i| @subs.values.each { |s| s.call i } } }
     end
     alias << push
 

data/lib/em/connection.rb

@@ -36,7 +36,7 @@ module EventMachine
       allocate.instance_eval do
         # Store signature
         @signature = sig
-        associate_callback_target sig
+        # associate_callback_target sig
 
         # Call a superclass's #initialize if it has one
         initialize(*args)
@@ -134,6 +134,11 @@ module EventMachine
     def proxy_target_unbound
     end
 
+    # EventMachine::Connection#proxy_completed is called when the reactor finished proxying all
+    # of the requested bytes.
+    def proxy_completed
+    end
+
     # EventMachine::Connection#proxy_incoming_to is called only by user code. It sets up
     # a low-level proxy relay for all data inbound for this connection, to the connection given
     # as the argument. This is essentially just a helper method for enable_proxy.

data/lib/em/deferrable.rb

@@ -51,6 +51,13 @@ module EventMachine
       end
     end
 
+    # Cancels an outstanding callback to &block if any. Undoes the action of #callback.
+    #
+    def cancel_callback block
+      @callbacks ||= []
+      @callbacks.delete block
+    end
+
     # Specify a block to be executed if and when the Deferrable object receives
     # a status of :failed. See #set_deferred_status for more information.
     #--
@@ -69,6 +76,13 @@ module EventMachine
       end
     end
 
+    # Cancels an outstanding errback to &block if any. Undoes the action of #errback.
+    #
+    def cancel_errback block
+      @errbacks ||= []
+      @errbacks.delete block
+    end
+
     # Sets the "disposition" (status) of the Deferrable object. See also the large set of
     # sugarings for this method.
     # Note that if you call this method without arguments,
@@ -150,10 +164,10 @@ module EventMachine
     # the Timeout expires (passing no arguments to the object's errbacks).
     # Setting the status at any time prior to a call to the expiration of the timeout
     # will cause the timer to be cancelled.
-    def timeout seconds
+    def timeout seconds, *args
       cancel_timeout
       me = self
-      @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail}
+      @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail(*args)}
     end
 
     # Cancels an outstanding timeout if any. Undoes the action of #timeout.

data/lib/em/file_watch.rb

@@ -1,54 +1,54 @@
-module EventMachine
-
-  # This is subclassed from EventMachine::Connection for use with the file monitoring API. Read the
-  # documentation on the instance methods of this class, and for a full explanation see EventMachine.watch_file.
-  class FileWatch < Connection
-    # :stopdoc:
-    Cmodified = 'modified'.freeze
-    Cdeleted = 'deleted'.freeze
-    Cmoved = 'moved'.freeze
-    # :startdoc:
-
-    def receive_data(data) #:nodoc:
-      case data
-      when Cmodified
-        file_modified
-      when Cdeleted
-        file_deleted
-      when Cmoved
-        file_moved
-      end
-    end
-
-    # Returns the path that EventMachine::watch_file was originally called with. The current implementation
-    # does not pick up on the new filename after a rename occurs.
-    def path
-      @path
-    end
-
-    # Should be redefined with the user's custom callback that will be fired when the file is modified.
-    def file_modified
-    end
-
-    # Should be redefined with the user's custom callback that will be fired when the file is deleted.
-    # When the file is deleted, stop_watching will be called after this to make sure everything is
-    # cleaned up correctly.
-    #
-    # Note that on linux (with inotify), file_deleted will not be called until all open file descriptors to
-    # the file have been closed.
-    def file_deleted
-    end
-
-    # Should be redefined with the user's custom callback that will be fired when the file is moved or renamed.
-    def file_moved
-    end
-
-    # Discontinue monitoring of the file.
-    # This involves cleaning up the underlying monitoring details with kqueue/inotify, and in turn firing unbind.
-    # This will be called automatically when a file is deleted. User code may call it as well.
-    def stop_watching
-      EventMachine::unwatch_filename(@signature)
-    end
-  end
-
+module EventMachine
+
+  # This is subclassed from EventMachine::Connection for use with the file monitoring API. Read the
+  # documentation on the instance methods of this class, and for a full explanation see EventMachine.watch_file.
+  class FileWatch < Connection
+    # :stopdoc:
+    Cmodified = 'modified'.freeze
+    Cdeleted = 'deleted'.freeze
+    Cmoved = 'moved'.freeze
+    # :startdoc:
+
+    def receive_data(data) #:nodoc:
+      case data
+      when Cmodified
+        file_modified
+      when Cdeleted
+        file_deleted
+      when Cmoved
+        file_moved
+      end
+    end
+
+    # Returns the path that EventMachine::watch_file was originally called with. The current implementation
+    # does not pick up on the new filename after a rename occurs.
+    def path
+      @path
+    end
+
+    # Should be redefined with the user's custom callback that will be fired when the file is modified.
+    def file_modified
+    end
+
+    # Should be redefined with the user's custom callback that will be fired when the file is deleted.
+    # When the file is deleted, stop_watching will be called after this to make sure everything is
+    # cleaned up correctly.
+    #
+    # Note that on linux (with inotify), file_deleted will not be called until all open file descriptors to
+    # the file have been closed.
+    def file_deleted
+    end
+
+    # Should be redefined with the user's custom callback that will be fired when the file is moved or renamed.
+    def file_moved
+    end
+
+    # Discontinue monitoring of the file.
+    # This involves cleaning up the underlying monitoring details with kqueue/inotify, and in turn firing unbind.
+    # This will be called automatically when a file is deleted. User code may call it as well.
+    def stop_watching
+      EventMachine::unwatch_filename(@signature)
+    end
+  end
+
 end

data/lib/em/future.rb

@@ -1,61 +1,61 @@
-#--
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 16 Jul 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.
-#
-#---------------------------------------------------------------------------
-#
-# 
-
-#--
-# This defines EventMachine::Deferrable#future, which requires
-# that the rest of EventMachine::Deferrable has already been seen.
-# (It's in deferrable.rb.)
-
-module EventMachine
-    module Deferrable
-
-      # A future is a sugaring of a typical deferrable usage.
-      #--
-      # Evaluate arg (which may be an expression or a block).
-      # What's the class of arg?
-      # If arg is an ordinary expression, then return it.
-      # If arg is deferrable (responds to :set_deferred_status),
-      # then look at the arguments. If either callback or errback
-      # are defined, then use them. If neither are defined, then
-      # use the supplied block (if any) as the callback.
-      # Then return arg.
-      def self.future arg, cb=nil, eb=nil, &blk
-        arg = arg.call if arg.respond_to?(:call)
-
-        if arg.respond_to?(:set_deferred_status)
-          if cb || eb
-            arg.callback(&cb) if cb
-            arg.errback(&eb) if eb
-          else
-            arg.callback(&blk) if blk
-          end
-        end
-
-        arg
-      end
-
-    end
-end
-
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 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.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+#--
+# This defines EventMachine::Deferrable#future, which requires
+# that the rest of EventMachine::Deferrable has already been seen.
+# (It's in deferrable.rb.)
+
+module EventMachine
+    module Deferrable
+
+      # A future is a sugaring of a typical deferrable usage.
+      #--
+      # Evaluate arg (which may be an expression or a block).
+      # What's the class of arg?
+      # If arg is an ordinary expression, then return it.
+      # If arg is deferrable (responds to :set_deferred_status),
+      # then look at the arguments. If either callback or errback
+      # are defined, then use them. If neither are defined, then
+      # use the supplied block (if any) as the callback.
+      # Then return arg.
+      def self.future arg, cb=nil, eb=nil, &blk
+        arg = arg.call if arg.respond_to?(:call)
+
+        if arg.respond_to?(:set_deferred_status)
+          if cb || eb
+            arg.callback(&cb) if cb
+            arg.errback(&eb) if eb
+          else
+            arg.callback(&blk) if blk
+          end
+        end
+
+        arg
+      end
+
+    end
+end
+

data/lib/em/iterator.rb

@@ -0,0 +1,270 @@
+module EventMachine
+  # A simple iterator for concurrent asynchronous work.
+  #
+  # Unlike ruby's built-in iterators, the end of the current iteration cycle is signaled manually,
+  # instead of happening automatically after the yielded block finishes executing. For example:
+  #
+  #  (0..10).each{ |num| }
+  #
+  # becomes:
+  #
+  #  EM::Iterator.new(0..10).each{ |num,iter| iter.next }
+  #
+  # This is especially useful when doing asynchronous work via reactor libraries and
+  # functions. For example, given a sync and async http api:
+  #
+  #  response = sync_http_get(url); ...
+  #  async_http_get(url){ |response| ... }
+  #
+  # a synchronous iterator such as:
+  #
+  #  responses = urls.map{ |url| sync_http_get(url) }
+  #  ...
+  #  puts 'all done!'
+  #
+  # could be written as:
+  #
+  #  EM::Iterator.new(urls).map(proc{ |url,iter|
+  #    async_http_get(url){ |res|
+  #      iter.return(res)
+  #    }
+  #  }, proc{ |responses|
+  #    ...
+  #    puts 'all done!'
+  #  })
+  #
+  # Now, you can take advantage of the asynchronous api to issue requests in parallel. For example,
+  # to fetch 10 urls at a time, simply pass in a concurrency of 10:
+  #
+  #  EM::Iterator.new(urls, 10).each do |url,iter|
+  #    async_http_get(url){ iter.next }
+  #  end
+  #
+  class Iterator
+    # Create a new parallel async iterator with specified concurrency.
+    #
+    #  i = EM::Iterator.new(1..100, 10)
+    #
+    # will create an iterator over the range that processes 10 items at a time. Iteration
+    # is started via #each, #map or #inject
+    #
+    def initialize(list, concurrency = 1)
+      raise ArgumentError, 'argument must be an array' unless list.respond_to?(:to_a)
+      @list = list.to_a.dup
+      @concurrency = concurrency
+
+      @started = false
+      @ended = false
+    end
+
+    # Change the concurrency of this iterator. Workers will automatically be spawned or destroyed
+    # to accomodate the new concurrency level.
+    #
+    def concurrency=(val)
+      old = @concurrency
+      @concurrency = val
+
+      spawn_workers if val > old and @started and !@ended
+    end
+    attr_reader :concurrency
+
+    # Iterate over a set of items using the specified block or proc.
+    #
+    #  EM::Iterator.new(1..100).each do |num, iter|
+    #    puts num
+    #    iter.next
+    #  end
+    #
+    # An optional second proc is invoked after the iteration is complete.
+    #
+    #  EM::Iterator.new(1..100).each(
+    #    proc{ |num,iter| iter.next },
+    #    proc{ puts 'all done' }
+    #  )
+    #
+    def each(foreach=nil, after=nil, &blk)
+      raise ArgumentError, 'proc or block required for iteration' unless foreach ||= blk
+      raise RuntimeError, 'cannot iterate over an iterator more than once' if @started or @ended
+
+      @started = true
+      @pending = 0
+      @workers = 0
+
+      all_done = proc{
+        after.call if after and @ended and @pending == 0
+      }
+
+      @process_next = proc{
+        # p [:process_next, :pending=, @pending, :workers=, @workers, :ended=, @ended, :concurrency=, @concurrency, :list=, @list]
+        unless @ended or @workers > @concurrency
+          if @list.empty?
+            @ended = true
+            @workers -= 1
+            all_done.call
+          else
+            item = @list.shift
+            @pending += 1
+
+            is_done = false
+            on_done = proc{
+              raise RuntimeError, 'already completed this iteration' if is_done
+              is_done = true
+
+              @pending -= 1
+
+              if @ended
+                all_done.call
+              else
+                EM.next_tick(@process_next)
+              end
+            }
+            class << on_done
+              alias :next :call
+            end
+
+            foreach.call(item, on_done)
+          end
+        else
+          @workers -= 1
+        end
+      }
+
+      spawn_workers
+
+      self
+    end
+
+    # Collect the results of an asynchronous iteration into an array.
+    #
+    #  EM::Iterator.new(%w[ pwd uptime uname date ], 2).map(proc{ |cmd,iter|
+    #    EM.system(cmd){ |output,status|
+    #      iter.return(output)
+    #    }
+    #  }, proc{ |results|
+    #    p results
+    #  })
+    #
+    def map(foreach, after)
+      index = 0
+
+      inject([], proc{ |results,item,iter|
+        i = index
+        index += 1
+
+        is_done = false
+        on_done = proc{ |res|
+          raise RuntimeError, 'already returned a value for this iteration' if is_done
+          is_done = true
+
+          results[i] = res
+          iter.return(results)
+        }
+        class << on_done
+          alias :return :call
+          def next
+            raise NoMethodError, 'must call #return on a map iterator'
+          end
+        end
+
+        foreach.call(item, on_done)
+      }, proc{ |results|
+        after.call(results)
+      })
+    end
+
+    # Inject the results of an asynchronous iteration onto a given object.
+    #
+    #  EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
+    #    EM.system(cmd){ |output,status|
+    #      hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+    #      iter.return(hash)
+    #    }
+    #  }, proc{ |results|
+    #    p results
+    #  })
+    #
+    def inject(obj, foreach, after)
+      each(proc{ |item,iter|
+        is_done = false
+        on_done = proc{ |res|
+          raise RuntimeError, 'already returned a value for this iteration' if is_done
+          is_done = true
+
+          obj = res
+          iter.next
+        }
+        class << on_done
+          alias :return :call
+          def next
+            raise NoMethodError, 'must call #return on an inject iterator'
+          end
+        end
+
+        foreach.call(obj, item, on_done)
+      }, proc{
+        after.call(obj)
+      })
+    end
+
+    private
+
+    # Spawn workers to consume items from the iterator's enumerator based on the current concurrency level.
+    #
+    def spawn_workers
+      EM.next_tick(start_worker = proc{
+        if @workers < @concurrency and !@ended
+          # p [:spawning_worker, :workers=, @workers, :concurrency=, @concurrency, :ended=, @ended]
+          @workers += 1
+          @process_next.call
+          EM.next_tick(start_worker)
+        end
+      })
+      nil
+    end
+  end
+end
+
+if __FILE__ == $0
+  $:.unshift File.join(File.dirname(__FILE__), '..')
+  require 'eventmachine'
+
+  # TODO: real tests
+  # TODO: pass in one object instead of two? .each{ |iter| puts iter.current; iter.next }
+  # TODO: support iter.pause/resume/stop/break/continue?
+  # TODO: create some exceptions instead of using RuntimeError
+  # TODO: support proc instead of enumerable? EM::Iterator.new(proc{ return queue.pop })
+
+  EM.run{
+    EM::Iterator.new(1..50).each{ |num,iter| p num; iter.next }
+    EM::Iterator.new([1,2,3], 10).each{ |num,iter| p num; iter.next }
+
+    i = EM::Iterator.new(1..100, 5)
+    i.each(proc{|num,iter|
+      p num.to_s
+      iter.next
+    }, proc{
+      p :done
+    })
+    EM.add_timer(0.03){
+      i.concurrency = 1
+    }
+    EM.add_timer(0.04){
+      i.concurrency = 3
+    }
+
+    EM::Iterator.new(100..150).map(proc{ |num,iter|
+      EM.add_timer(0.01){ iter.return(num) }
+    }, proc{ |results|
+      p results
+    })
+
+    EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
+      EM.system(cmd){ |output,status|
+        hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+        iter.return(hash)
+      }
+    }, proc{ |results|
+      p results
+    })
+  }
+end