spawnling 2.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 22c752d3c7f7e6f38838941833c5b3e05cd376e1
+  metadata.gz: 3ed0947f67a6a6937970268bcb2988dc56184dda
+SHA512: 
+  data.tar.gz: 858a4f1a283da28138a84b801f2943901a86bf49250804bd46477f01b5e667927bab24de0350a5f8887f210af57ae233b3e2cb45647404ff0677bb877eb3ca8c
+  metadata.gz: 949044c486e08b519984b6734c009568143d7d64325838f8df47f6cee75d0e8903a831f3552cf4373d25ca8a749381067fae25c327357609c917e11182f7e3a0

data/CHANGELOG

@@ -0,0 +1,55 @@
+v0.1 - 2007/09/13
+
+initial version
+
+--------------------------------------------------
+v0.2 - 2007/09/28
+
+* return PID of the child process
+* added ":detach => false" option
+
+--------------------------------------------------
+v0.3 - 2007/10/15
+
+* added ':method => :thread' for threaded spawns
+* removed ':detach => false' option in favor of more generic implementation
+* added ability to set configuration of the form 'Spawn::method :thread'
+* added patch to ActiveRecord::Base to allow for more efficient reconnect in child processes
+* added monkey patch for http://dev.rubyonrails.org/ticket/7579
+* added wait() method to wait for spawned code blocks
+* don't allow threading if allow_concurrency=false
+
+--------------------------------------------------
+v0.4 - 2008/1/26
+
+* default to :thread on windows, still :fork on all other platforms
+* raise exception when used with :method=>:true and allow_concurrency != true
+
+--------------------------------------------------
+v0.5 - 2008/3/1
+* also default to :thread on JRuby (java)
+* added new :method => :yield which doesn't fork or thread, this is useful for testing
+* fixed problem with connections piling up on PostgreSQL
+
+--------------------------------------------------
+v0.6 - 2008/04/21
+* only apply clear_reloadable_connections patch on Rails 1.x (7579 fixed in Rails 2.x)
+* made it more responsive in more environments by disconnecting from the listener socket in the forked process
+
+--------------------------------------------------
+v0.7 - 2008/04/24
+* more generic mechanism for closing resources after fork
+* check for existence of Mongrel before patching it
+
+--------------------------------------------------
+v0.8 - 2008/05/02
+* call exit! within the ensure block so that at_exit handlers aren't called on exceptions
+* set logger from RAILS_DEFAULT_LOGGER if available, else STDERR
+
+--------------------------------------------------
+v0.9 - 2008/05/11
+* added ability to set nice level for child process
+
+--------------------------------------------------
+v1.0 - 2010/10/09
+* merged edged to master, let's call this version 1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007 Tom Anderson (tom@squeat.com)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+#News
+
+Now runs with ruby 1.9 (and later).  Because ruby "stole" the name "spawn", this gem
+now has been redefined to use "Spawn.new(&block)" instead of "spawn(&block)".  Other
+than that nothing has changed in the basic usage.  Read below for detailed usage.
+
+# Spawn
+
+This gem provides a 'Spawn' class to easily fork OR thread long-running sections of
+code so that your application can return results to your users more quickly.
+It works by creating new database connections in ActiveRecord::Base for the
+spawned block so that you don't have to worry about database connections working,
+they just do.
+
+The gem also patches ActiveRecord::Base to handle some known bugs when using
+threads if you prefer using the threaded model over forking.
+
+## Installation
+
+The name of the gem is "spawn-block" (unfortunately somebody took the name "spawn" before
+I was able to convert this to a gem).
+
+### git
+
+If you want to live on the latest master branch, add this to your Gemfile,
+
+    gem 'spawn-block', :git => 'git://github.com/tra/spawn'
+
+and use bundler to manage it (bundle install, bundle update).
+
+### rubygem
+
+If you'd rather install from the latest gem,
+
+    gem 'spawn-block', '~>2.0'
+
+### configure
+
+Make sure that ActiveRecord reconnects to your database automatically when needed,
+for instance put
+
+    production/development:
+      ...
+      reconnect: true
+
+into your config/database.yml.
+
+## Usage
+
+Here's a simple example of how to demonstrate the spawn plugin.
+In one of your controllers, insert this code (after installing the plugin of course):
+```ruby
+Spawn.new do
+  logger.info("I feel sleepy...")
+  sleep 11
+  logger.info("Time to wake up!")
+end
+```
+If everything is working correctly, your controller should finish quickly then you'll see
+the last log message several seconds later.
+
+If you need to wait for the spawned processes/threads, then pass the objects returned by
+spawn to Spawn.wait(), like this:
+```ruby
+spawns = []
+N.times do |i|
+  # spawn N blocks of code
+  spawns << Spawn.new do
+    something(i)
+  end
+end
+# wait for all N blocks of code to finish running
+Spawn.wait(spawns)
+```
+## Options
+
+The options you can pass to spawn are:
+
+<table>
+  <tr><th>Option</th><th>Values</th></tr>
+  <tr><td>:method</td><td>:fork, :thread, :yield</td></tr>
+  <tr><td>:nice</td><td>integer value 0-19, 19 = really nice</td></tr>
+  <tr><td>:kill</td><td>boolean value indicating whether the parent should kill the spawned process
+   when it exits (only valid when :method => :fork)</td></tr>
+  <tr><td>:argv</td><td>string to override the process name</td></tr>
+</table>
+
+Any option to spawn can be set as a default so that you don't have to pass them in
+to every call of spawn.   To configure the spawn default options, add a line to
+your configuration file(s) like this:
+```ruby
+  Spawn::default_options {:method => :thread}
+```
+If you don't set any default options, the :method will default to :fork.  To
+specify different values for different environments, add the default_options call to
+he appropriate environment file (development.rb, test.rb).   For testing you can set
+the default :method to :yield so that the code is run inline.
+```ruby
+  # in environment.rb
+  Spawn.method :method => :fork, :nice => 7
+  # in test.rb, will override the environment.rb setting
+  Spawn.method :method => :yield
+```
+This allows you to set your production and development environments to use different
+methods according to your needs.
+
+### be nice
+
+If you want your forked child to run at a lower priority than the parent process, pass in
+the :nice option like this:
+```ruby
+Spawn.new(:nice => 7) do
+  do_something_nicely
+end
+```
+### fork me
+
+By default, spawn will use the fork to spawn child processes.  You can configure it to
+do threading either by telling the spawn method when you call it or by configuring your
+environment.
+For example, this is how you can tell spawn to use threading on the call,
+```ruby
+Spawn.new(:method => :thread) do
+  something
+end
+```
+When you use threaded spawning, make sure that your application is thread-safe. Rails
+can be switched to thread-safe mode with (not sure if this is needed anymore)
+```ruby
+  # Enable threaded mode
+  config.threadsafe!
+```
+in environments/your_environment.rb
+
+### kill or be killed
+
+Depending on your application, you may want the children processes to go away when
+the parent  process exits.   By default spawn lets the children live after the
+parent dies.   But you can tell it to kill the children by setting the :kill option
+to true.
+
+### a process by any other name
+
+If you'd like to be able to identify which processes are spawned by looking at the
+output of ps then set the :argv option with a string of your choice.
+You should then be able to see this string as the process name when
+listing the running processes (ps).
+
+For example, if you do something like this,
+```ruby
+3.times do |i|
+ Spawn.new(:argv => "spawn -#{i}-") do
+   something(i)
+  end
+end
+```
+then in the shell,
+```shell
+$ ps -ef | grep spawn
+502  2645  2642   0   0:00.01 ttys002    0:00.02 spawn -0-
+502  2646  2642   0   0:00.02 ttys002    0:00.02 spawn -1-
+502  2647  2642   0   0:00.02 ttys002    0:00.03 spawn -2-
+```
+The length of the process name may be limited by your OS so you might want to experiment
+to see how long it can be (it may be limited by the length of the original process name).
+
+## Forking vs. Threading
+
+There are several tradeoffs for using threading vs. forking.   Forking was chosen as the
+default primarily because it requires no configuration to get it working out of the box.
+
+Forking advantages:
+
+- more reliable? - the ActiveRecord code is generally not deemed to be thread-safe.
+  Even though spawn attempts to patch known problems with the threaded implementation,
+  there are no guarantees.  Forking is heavier but should be fairly reliable.
+- keep running - this could also be a disadvantage, but you may find you want to fork
+  off a process that could have a life longer than its parent.  For example, maybe you
+  want to restart your server without killing the spawned processes.
+  We don't necessarily condone this (i.e. haven't tried it) but it's technically possible.
+- easier - forking works out of the box with spawn, threading requires you set
+  allow_concurrency=true (for older versions of Rails).
+  Also, beware of automatic reloading of classes in development
+  mode (config.cache_classes = false).
+
+Threading advantages:
+- less filling - threads take less resources... how much less?  it depends.   Some
+  flavors of Unix are pretty efficient at forking so the threading advantage may not
+  be as big as you think... but then again, maybe it's more than you think.  :wink:
+- debugging - you can set breakpoints in your threads
+
+## Acknowledgements
+
+This plugin was initially inspired by Scott Persinger's blog post on how to use fork
+in rails for background processing (link no longer available).
+
+Further inspiration for the threading implementation came from [Jonathon Rochkind's
+blog post](http://bibwild.wordpress.com/2007/08/28/threading-in-rails/) on threading in rails.
+
+Also thanks to all who have helped debug problems and suggest improvements
+including:
+
+-  Ahmed Adam, Tristan Schneiter, Scott Haug, Andrew Garfield, Eugene Otto, Dan Sharp,
+  Olivier Ruffin, Adrian Duyzer, Cyrille Labesse
+
+-  Garry Tan, Matt Jankowski (Rails 2.2.x fixes), Mina Naguib (Rails 2.3.6 fix)
+
+-  Tim Kadom, Mauricio Marcon Zaffari, Danial Pearce, Hongli Lai, Scott Wadden
+  (passenger fixes)
+
+- Will Bryant, James Sanders (memcache fix)
+
+- David Kelso, Richard Hirner, Luke van der Hoeven (gemification and Rails 3 support)
+
+- Jay Caines-Gooby, Eric Stewart (Unicorn fix)
+
+- Dan Sharp for the changes that allow it to work with Ruby 1.9 and later
+
+-  &lt;your name here&gt;
+
+Copyright (c) 2007-present Tom Anderson (tom@squeat.com), see LICENSE

data/init.rb

@@ -0,0 +1 @@
+require 'spawn'

data/lib/patches.rb

@@ -0,0 +1,135 @@
+if defined?(ActiveRecord)
+  # see activerecord/lib/active_record/connection_adaptors/abstract/connection_specification.rb
+  class ActiveRecord::Base
+    # reconnect without disconnecting
+    if ::Spawn::RAILS_3_x || ::Spawn::RAILS_2_2
+      def self.spawn_reconnect(klass=self)
+        # keep ancestors' connection_handlers around to avoid them being garbage collected in the forked child
+        @@ancestor_connection_handlers ||= []
+        @@ancestor_connection_handlers << self.connection_handler
+        self.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+
+        establish_connection
+      end
+    else
+      def self.spawn_reconnect(klass=self)
+        spec = @@defined_connections[klass.name]
+        konn = active_connections[klass.name]
+        # remove from internal arrays before calling establish_connection so that
+        # the connection isn't disconnected when it calls AR::Base.remove_connection
+        @@defined_connections.delete_if { |key, value| value == spec }
+        active_connections.delete_if { |key, value| value == konn }
+        establish_connection(spec ? spec.config : nil)
+      end
+    end
+
+    # this patch not needed on Rails 2.x and later
+    if ::Spawn::RAILS_1_x
+      # monkey patch to fix threading problems,
+      # see: http://dev.rubyonrails.org/ticket/7579
+      def self.clear_reloadable_connections!
+        if @@allow_concurrency
+          # Hash keyed by thread_id in @@active_connections. Hash of hashes.
+          @@active_connections.each do |thread_id, conns|
+            conns.each do |name, conn|
+              if conn.requires_reloading?
+                conn.disconnect!
+                @@active_connections[thread_id].delete(name)
+              end
+            end
+          end
+        else
+          # Just one level hash, no concurrency.
+          @@active_connections.each do |name, conn|
+            if conn.requires_reloading?
+              conn.disconnect!
+              @@active_connections.delete(name)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# just borrowing from the mongrel & passenger patches:
+if defined?(Unicorn::HttpServer) && defined?(Unicorn::HttpRequest::REQ)
+  class Unicorn::HttpServer
+    REQ = Unicorn::HttpRequest::REQ
+    alias_method :orig_process_client, :process_client
+    def process_client(client)
+      ::Spawn.resources_to_close(client, REQ)
+      orig_process_client(client)
+    end
+  end
+elsif defined? Unicorn::HttpServer
+  class Unicorn::HttpServer
+    alias_method :orig_process_client, :process_client
+    def process_client(client)
+      ::Spawn.resources_to_close(client, @request)
+      orig_process_client(client)
+    end
+  end
+end
+
+# see mongrel/lib/mongrel.rb
+# it's possible that this is not defined if you're running outside of mongrel
+# examples: ./script/runner or ./script/console
+if defined? Mongrel::HttpServer
+  class Mongrel::HttpServer
+    # redefine Montrel::HttpServer::process_client so that we can intercept
+    # the socket that is being used so Spawn can close it upon forking
+    alias_method :orig_process_client, :process_client
+    def process_client(client)
+      ::Spawn.resources_to_close(client, @socket)
+      orig_process_client(client)
+    end
+  end
+end
+
+need_passenger_patch = true
+if defined? PhusionPassenger::VERSION_STRING
+  # The VERSION_STRING variable was defined sometime after 2.1.0.
+  # We don't need passenger patch for 2.2.2 or later.
+  pv = PhusionPassenger::VERSION_STRING.split('.').collect{|s| s.to_i}
+  need_passenger_patch = pv[0] < 2 || (pv[0] == 2 && (pv[1] < 2 || (pv[1] == 2 && pv[2] < 2)))
+end
+
+if need_passenger_patch
+  # Patch for work with passenger < 2.1.0
+  if defined? Passenger::Railz::RequestHandler
+    class Passenger::Railz::RequestHandler
+      alias_method :orig_process_request, :process_request
+      def process_request(headers, input, output)
+        ::Spawn.resources_to_close(input, output)
+        orig_process_request(headers, input, output)
+      end
+    end
+  end
+
+  # Patch for work with passenger >= 2.1.0
+  if defined? PhusionPassenger::Railz::RequestHandler
+    class PhusionPassenger::Railz::RequestHandler
+      alias_method :orig_process_request, :process_request
+      def process_request(headers, input, output)
+        ::Spawn.resources_to_close(input, output)
+        orig_process_request(headers, input, output)
+      end
+    end
+  end
+
+  # Patch for passenger with Rails >= 2.3.0 (uses rack)
+  if defined? PhusionPassenger::Rack::RequestHandler
+    class PhusionPassenger::Rack::RequestHandler
+      alias_method :orig_process_request, :process_request
+      def process_request(headers, input, output)
+        ::Spawn.resources_to_close(input, output)
+        orig_process_request(headers, input, output)
+      end
+    end
+  end
+end
+
+if defined?(::ActiveSupport::Cache::MemCacheStore) && ::ActiveSupport::Cache.autoload?(:MemCacheStore).nil?
+  ::ActiveSupport::Cache::MemCacheStore.delegate :reset, :to => :@data
+end

data/lib/spawn.rb

@@ -0,0 +1,223 @@
+require 'logger'
+
+class Spawn
+  if defined? ::Rails
+    RAILS_1_x = (::Rails::VERSION::MAJOR == 1) unless defined?(RAILS_1_x)
+    RAILS_2_2 = ((::Rails::VERSION::MAJOR == 2 && ::Rails::VERSION::MINOR >= 2)) unless defined?(RAILS_2_2)
+    RAILS_3_x = (::Rails::VERSION::MAJOR > 2) unless defined?(RAILS_3_x)
+  else
+    RAILS_1_x = nil
+    RAILS_2_2 = nil
+    RAILS_3_x = nil
+  end
+
+  @@default_options = {
+    # default to forking (unless windows or jruby)
+    :method => ((RUBY_PLATFORM =~ /(win32|mingw32|java)/) ? :thread : :fork),
+    :nice   => nil,
+    :kill   => false,
+    :argv   => nil
+  }
+
+  # things to close in child process
+  @@resources = []
+
+  # forked children to kill on exit
+  @@punks = []
+
+  # in some environments, logger isn't defined
+  @@logger = defined?(::Rails) ? ::Rails.logger : ::Logger.new(STDERR)
+
+  attr_accessor :type
+  attr_accessor :handle
+
+  # Set the options to use every time spawn is called unless specified
+  # otherwise.  For example, in your environment, do something like
+  # this:
+  #   Spawn::default_options = {:nice => 5}
+  # to default to using the :nice option with a value of 5 on every call.
+  # Valid options are:
+  #   :method => (:thread | :fork | :yield)
+  #   :nice   => nice value of the forked process
+  #   :kill   => whether or not the parent process will kill the
+  #              spawned child process when the parent exits
+  #   :argv   => changes name of the spawned process as seen in ps
+  def self.default_options(options = {})
+    @@default_options.merge!(options)
+    @@logger.info "spawn> default options = #{options.inspect}" if @@logger
+  end
+
+  # set the resources to disconnect from in the child process (when forking)
+  def self.resources_to_close(*resources)
+    @@resources = resources
+  end
+
+  # close all the resources added by calls to resource_to_close
+  def self.close_resources
+    @@resources.each do |resource|
+      resource.close if resource && resource.respond_to?(:close) && !resource.closed?
+    end
+    # in case somebody spawns recursively
+    @@resources.clear
+  end
+
+  def self.alive?(pid)
+    begin
+      Process::kill 0, pid
+      # if the process is alive then kill won't throw an exception
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+
+  def self.kill_punks
+    @@punks.each do |punk|
+      if alive?(punk)
+        @@logger.info "spawn> parent(#{Process.pid}) killing child(#{punk})" if @@logger
+        begin
+          Process.kill("TERM", punk)
+        rescue
+        end
+      end
+    end
+    @@punks = []
+  end
+  # register to kill marked children when parent exits
+  at_exit { Spawn.kill_punks }
+
+  # Spawns a long-running section of code and returns the ID of the spawned process.
+  # By default the process will be a forked process.   To use threading, pass
+  # :method => :thread or override the default behavior in the environment by setting
+  # 'Spawn::method :thread'.
+  def initialize(opts = {})
+    raise "Must give block of code to be spawned" unless block_given?
+    options = @@default_options.merge(symbolize_options(opts))
+    # setting options[:method] will override configured value in default_options[:method]
+    if options[:method] == :yield
+      yield
+    elsif options[:method].respond_to?(:call)
+      options[:method].call(proc { yield })
+    elsif options[:method] == :thread
+      # for versions before 2.2, check for allow_concurrency
+     if RAILS_2_2 || ActiveRecord::Base.respond_to?(:allow_concurrency) ?
+          ActiveRecord::Base.allow_concurrency :  Rails.application.config.allow_concurrency
+       @type = :thread
+       @handle = thread_it(options) { yield }
+      else
+        @@logger.error("spawn(:method=>:thread) only allowed when allow_concurrency=true")
+        raise "spawn requires config.active_record.allow_concurrency=true when used with :method=>:thread"
+      end
+    else
+      @type = :fork
+      @handle = fork_it(options) { yield }
+    end
+  end
+
+  def self.wait(sids = [])
+    # wait for all threads and/or forks (if a single sid passed in, convert to array first)
+    Array(sids).each do |sid|
+      if sid.type == :thread
+        sid.handle.join()
+      else
+        begin
+          Process.wait(sid.handle)
+        rescue
+          # if the process is already done, ignore the error
+        end
+      end
+    end
+    # clean up connections from expired threads
+    ActiveRecord::Base.verify_active_connections!() if defined?(ActiveRecord)
+  end
+
+  protected
+
+  def fork_it(options)
+    # The problem with rails is that it only has one connection (per class),
+    # so when we fork a new process, we need to reconnect.
+    @@logger.debug "spawn> parent PID = #{Process.pid}" if @@logger
+    child = fork do
+      begin
+        start = Time.now
+        @@logger.debug "spawn> child PID = #{Process.pid}" if @@logger
+
+        # this child has no children of it's own to kill (yet)
+        @@punks = []
+
+        # set the nice priority if needed
+        Process.setpriority(Process::PRIO_PROCESS, 0, options[:nice]) if options[:nice]
+
+        # disconnect from the listening socket, et al
+        Spawn.close_resources
+        if defined?(Rails)
+          # get a new database connection so the parent can keep the original one
+          ActiveRecord::Base.spawn_reconnect
+          # close the memcache connection so the parent can keep the original one
+          Rails.cache.reset if Rails.cache.respond_to?(:reset)
+        end
+
+        # set the process name
+        $0 = options[:argv] if options[:argv]
+
+        # run the block of code that takes so long
+        yield
+
+      rescue => ex
+        @@logger.error "spawn> Exception in child[#{Process.pid}] - #{ex.class}: #{ex.message}" if @@logger
+        @@logger.error "spawn> " + ex.backtrace.join("\n") if @@logger
+      ensure
+        begin
+          # to be safe, catch errors on closing the connnections too
+          ActiveRecord::Base.connection_handler.clear_all_connections! if defined?(ActiveRecord)
+        ensure
+          @@logger.info "spawn> child[#{Process.pid}] took #{Time.now - start} sec" if @@logger
+          # ensure log is flushed since we are using exit!
+          @@logger.flush if @@logger && @@logger.respond_to?(:flush)
+          # this child might also have children to kill if it called spawn
+          Spawn.kill_punks
+          # this form of exit doesn't call at_exit handlers
+          exit!(0)
+        end
+      end
+    end
+
+    # detach from child process (parent may still wait for detached process if they wish)
+    Process.detach(child)
+
+    # remove dead children from the target list to avoid memory leaks
+    @@punks.delete_if {|punk| !alive?(punk)}
+
+    # mark this child for death when this process dies
+    if options[:kill]
+      @@punks << child
+      @@logger.debug "spawn> death row = #{@@punks.inspect}" if @@logger
+    end
+
+    # return Spawn::Id.new(:fork, child)
+    return child
+  end
+
+  def thread_it(options)
+    # clean up stale connections from previous threads
+    ActiveRecord::Base.verify_active_connections!() if defined?(ActiveRecord)
+    thr = Thread.new do
+      # run the long-running code block
+      ActiveRecord::Base.connection_pool.with_connection { yield  }
+    end
+    thr.priority = -options[:nice] if options[:nice]
+    return thr
+  end
+
+  # In case we don't have rails, can't call opts.symbolize_keys
+  def symbolize_options(hash)
+    hash.inject({}) do |new_hash, (key, value)|
+      new_hash[key.to_sym] = value
+      new_hash
+    end
+  end
+end
+Spawnling = Spawn
+
+# patches depends on Spawn so require it after the class
+require 'patches'

data/lib/spawn/cucumber.rb

@@ -0,0 +1,32 @@
+module SpawnExtensions
+  # FIXME don't know how to tell Spawn to use #add_spawn_proc without extended
+  # using extended forces to make methods class methods while this is not very clean
+  def self.extended(base)
+    Spawn::method proc{ |block| add_spawn_proc(block) }
+  end
+
+  # Calls the spawn that was created 
+  # 
+  # Can be used to keep control over forked processes in your tests
+  def call_last_spawn_proc
+    spawns = SpawnExtensions.spawn_procs
+
+    raise "No spawn procs left" if spawns.empty?
+    
+    spawns.pop.call
+  end
+
+  private
+
+  def self.spawn_procs
+    @@spawn_procs ||= []
+  end
+
+  def self.add_spawn_proc(block)
+    spawn_procs << block
+  end
+  
+end
+
+# Extend cucumber to take control over spawns
+World(SpawnExtensions)

data/spec/spawn/spawn_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spawn do
+
+  describe "yields" do
+    before(:each) do
+      Spawn::method :yield
+      define_spawned
+    end
+  
+    it "should be able to yield directly" do
+      Spawned.hello.should == "hello"
+    end
+  end
+  
+  describe "override" do
+    before(:each) do
+      Spawn::method(proc{ "foo" })
+      define_spawned
+    end
+    
+    it "should be able to return a proc" do
+      Spawned.hello.should == "foo"
+    end
+    
+  end
+  
+  describe "delegate to a proc" do
+    before(:each) do
+      Spawn::method( proc{ |block| block  })
+      define_spawned
+    end
+    
+    it "should be able to return a proc" do
+      Spawned.hello.should be_kind_of(Proc)
+    end
+  
+    it "should be able to return a proc" do
+      Spawned.hello.call.should == "hello"
+    end
+    
+  end
+  
+  after(:each) do
+    Object.send(:remove_const, :Spawned)
+  end
+  
+  def define_spawned
+    cls = Class.new do
+      extend Spawn
+    
+      def self.hello
+        spawn do
+          "hello"
+        end
+      end
+      
+    end
+    
+    Object.const_set :Spawned, cls
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require 'active_record'
+require 'action_controller'
+require 'rails/version'
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'spawn'
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: spawnling
+version: !ruby/object:Gem::Version 
+  version: "2.1"
+platform: ruby
+authors: 
+- Tom Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-08 00:00:00 Z
+dependencies: []
+
+description: |-
+  This plugin provides a 'Spawn' class to easily fork OR
+  thread long-running sections of code so that your application can return
+  results to your users more quickly.  This plugin works by creating new database
+  connections in ActiveRecord::Base for the spawned block.
+  
+  The plugin also patches ActiveRecord::Base to handle some known bugs when using
+  threads (see lib/patches.rb).
+email: 
+- tom@squeat.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/patches.rb
+- lib/spawn/cucumber.rb
+- lib/spawn.rb
+- spec/spawn/spawn_spec.rb
+- spec/spec_helper.rb
+- CHANGELOG
+- LICENSE
+- README.md
+- init.rb
+homepage: http://github.com/tra/spawn
+licenses: []
+
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Easily fork OR thread long-running sections of code in Ruby
+test_files: []
+