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

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/spawnable.rb

@@ -1,85 +1,85 @@
-#--
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 25 Aug 2007
-# 
-# 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.
-#
-#---------------------------------------------------------------------------
-#
-#
-
-module EventMachine
-  # Support for Erlang-style processes.
-  #
-  class SpawnedProcess
-    # Send a message to the spawned process
-    def notify *x
-      me = self
-      EM.next_tick {
-        # A notification executes in the context of this
-        # SpawnedProcess object. That makes self and notify
-        # work as one would expect.
-        #
-        y = me.call(*x)
-        if y and y.respond_to?(:pull_out_yield_block)
-          a,b = y.pull_out_yield_block
-          set_receiver a
-          self.notify if b
-        end
-      }
-    end
-    alias_method :resume, :notify
-    alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
-    #attr_accessor :receiver
-
-    #--
-    # I know I'm missing something stupid, but the inside of class << s
-    # can't see locally-bound values. It can see globals, though.
-    def set_receiver blk
-      $em______tmpglobal = blk
-      class << self
-        define_method :call, $em______tmpglobal.dup
-      end
-    end
-
-  end
-
-  class YieldBlockFromSpawnedProcess # :nodoc:
-    def initialize block, notify
-      @block = [block,notify]
-    end
-    def pull_out_yield_block
-      @block
-    end
-  end
-
-  # Spawn an erlang-style process
-  def self.spawn &block
-    s = SpawnedProcess.new
-    s.set_receiver block
-    s
-  end
-
-  def self.yield &block # :nodoc:
-    return YieldBlockFromSpawnedProcess.new( block, false )
-  end
-
-  def self.yield_and_notify &block # :nodoc:
-    return YieldBlockFromSpawnedProcess.new( block, true )
-  end
-end
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 25 Aug 2007
+# 
+# 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.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module EventMachine
+  # Support for Erlang-style processes.
+  #
+  class SpawnedProcess
+    # Send a message to the spawned process
+    def notify *x
+      me = self
+      EM.next_tick {
+        # A notification executes in the context of this
+        # SpawnedProcess object. That makes self and notify
+        # work as one would expect.
+        #
+        y = me.call(*x)
+        if y and y.respond_to?(:pull_out_yield_block)
+          a,b = y.pull_out_yield_block
+          set_receiver a
+          self.notify if b
+        end
+      }
+    end
+    alias_method :resume, :notify
+    alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+    #attr_accessor :receiver
+
+    #--
+    # I know I'm missing something stupid, but the inside of class << s
+    # can't see locally-bound values. It can see globals, though.
+    def set_receiver blk
+      $em______tmpglobal = blk
+      class << self
+        define_method :call, $em______tmpglobal.dup
+      end
+    end
+
+  end
+
+  class YieldBlockFromSpawnedProcess # :nodoc:
+    def initialize block, notify
+      @block = [block,notify]
+    end
+    def pull_out_yield_block
+      @block
+    end
+  end
+
+  # Spawn an erlang-style process
+  def self.spawn &block
+    s = SpawnedProcess.new
+    s.set_receiver block
+    s
+  end
+
+  def self.yield &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, false )
+  end
+
+  def self.yield_and_notify &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, true )
+  end
+end

data/lib/em/streamer.rb

@@ -1,130 +1,130 @@
-#--
-#
-# 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.
-#
-#---------------------------------------------------------------------------
-#
-# 
-
-
-module EventMachine
-  class FileStreamer
-    include Deferrable
-
-    # Use mapped streamer for files bigger than 16k
-    MappingThreshold = 16384
-    # Wait until next tick to send more data when 50k is still in the outgoing buffer
-    BackpressureLevel = 50000
-    # Send 16k chunks at a time
-    ChunkSize = 16384
-
-    # Stream a file over a given connection. An optional :http_chunks => true argument will
-    # use HTTP 1.1 style chunked-encoding semantics.
-    #
-    #  module FileSender
-    #    def post_init
-    #      streamer = EventMachine::FileStreamer.new(self, '/tmp/bigfile.tar')
-    #      streamer.callback{
-    #        # file was sent successfully
-    #        close_connection_after_writing
-    #      }
-    #    end
-    #  end
-    #
-    def initialize connection, filename, args = {}
-      @connection = connection
-      @http_chunks = args[:http_chunks]
-
-      if File.exist?(filename)
-        @size = File.size?(filename)
-        if @size <= MappingThreshold
-          stream_without_mapping filename
-        else
-          stream_with_mapping filename
-        end
-      else
-        fail "file not found"
-      end
-    end
-
-    def stream_without_mapping filename # :nodoc:
-      if @http_chunks
-        @connection.send_data "#{@size.to_s(16)}\r\n"
-        @connection.send_file_data filename
-        @connection.send_data "\r\n0\r\n\r\n"
-      else
-        @connection.send_file_data filename
-      end
-      succeed
-    end
-    private :stream_without_mapping
-
-    def stream_with_mapping filename # :nodoc:
-      ensure_mapping_extension_is_present
-
-      @position = 0
-      @mapping = EventMachine::FastFileReader::Mapper.new filename
-      stream_one_chunk
-    end
-    private :stream_with_mapping
-
-    # Used internally to stream one chunk at a time over multiple reactor ticks
-    def stream_one_chunk
-      loop {
-        if @position < @size
-          if @connection.get_outbound_data_size > BackpressureLevel
-            EventMachine::next_tick {stream_one_chunk}
-            break
-          else
-            len = @size - @position
-            len = ChunkSize if (len > ChunkSize)
-
-            @connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
-            @connection.send_data( @mapping.get_chunk( @position, len ))
-            @connection.send_data("\r\n") if @http_chunks
-
-            @position += len
-          end
-        else
-          @connection.send_data "0\r\n\r\n" if @http_chunks
-          @mapping.close
-          succeed
-          break
-        end
-      }
-    end
-
-    #--
-    # We use an outboard extension class to get memory-mapped files.
-    # It's outboard to avoid polluting the core distro, but that means
-    # there's a "hidden" dependency on it. The first time we get here in
-    # any run, try to load up the dependency extension. User code will see
-    # a LoadError if it's not available, but code that doesn't require
-    # mapped files will work fine without it. This is a somewhat difficult
-    # compromise between usability and proper modularization.
-    #
-    def ensure_mapping_extension_is_present # :nodoc:
-      @@fastfilereader ||= (require 'fastfilereaderext')
-    end
-    private :ensure_mapping_extension_is_present
-
-  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.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+module EventMachine
+  class FileStreamer
+    include Deferrable
+
+    # Use mapped streamer for files bigger than 16k
+    MappingThreshold = 16384
+    # Wait until next tick to send more data when 50k is still in the outgoing buffer
+    BackpressureLevel = 50000
+    # Send 16k chunks at a time
+    ChunkSize = 16384
+
+    # Stream a file over a given connection. An optional :http_chunks => true argument will
+    # use HTTP 1.1 style chunked-encoding semantics.
+    #
+    #  module FileSender
+    #    def post_init
+    #      streamer = EventMachine::FileStreamer.new(self, '/tmp/bigfile.tar')
+    #      streamer.callback{
+    #        # file was sent successfully
+    #        close_connection_after_writing
+    #      }
+    #    end
+    #  end
+    #
+    def initialize connection, filename, args = {}
+      @connection = connection
+      @http_chunks = args[:http_chunks]
+
+      if File.exist?(filename)
+        @size = File.size(filename)
+        if @size <= MappingThreshold
+          stream_without_mapping filename
+        else
+          stream_with_mapping filename
+        end
+      else
+        fail "file not found"
+      end
+    end
+
+    def stream_without_mapping filename # :nodoc:
+      if @http_chunks
+        @connection.send_data "#{@size.to_s(16)}\r\n"
+        @connection.send_file_data filename
+        @connection.send_data "\r\n0\r\n\r\n"
+      else
+        @connection.send_file_data filename
+      end
+      succeed
+    end
+    private :stream_without_mapping
+
+    def stream_with_mapping filename # :nodoc:
+      ensure_mapping_extension_is_present
+
+      @position = 0
+      @mapping = EventMachine::FastFileReader::Mapper.new filename
+      stream_one_chunk
+    end
+    private :stream_with_mapping
+
+    # Used internally to stream one chunk at a time over multiple reactor ticks
+    def stream_one_chunk
+      loop {
+        if @position < @size
+          if @connection.get_outbound_data_size > BackpressureLevel
+            EventMachine::next_tick {stream_one_chunk}
+            break
+          else
+            len = @size - @position
+            len = ChunkSize if (len > ChunkSize)
+
+            @connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
+            @connection.send_data( @mapping.get_chunk( @position, len ))
+            @connection.send_data("\r\n") if @http_chunks
+
+            @position += len
+          end
+        else
+          @connection.send_data "0\r\n\r\n" if @http_chunks
+          @mapping.close
+          succeed
+          break
+        end
+      }
+    end
+
+    #--
+    # We use an outboard extension class to get memory-mapped files.
+    # It's outboard to avoid polluting the core distro, but that means
+    # there's a "hidden" dependency on it. The first time we get here in
+    # any run, try to load up the dependency extension. User code will see
+    # a LoadError if it's not available, but code that doesn't require
+    # mapped files will work fine without it. This is a somewhat difficult
+    # compromise between usability and proper modularization.
+    #
+    def ensure_mapping_extension_is_present # :nodoc:
+      @@fastfilereader ||= (require 'fastfilereaderext')
+    end
+    private :ensure_mapping_extension_is_present
+
+  end
+end
+

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