tmp8-snailgun 1.2.0

data/README-snowleopard

@@ -0,0 +1,15 @@
+If you use ruby-1.9.2-p0 on Snow Leopard snailgun won't work out of the Box!
+
+I have included a small patch to the ruby-sources that make it work:
+
+(this is assuming you use rvm)
+
+cd $HOME/.rvm/src/ruby-1.9.2-p0/ext/socket
+patch -p1 < wherever_snailgun_was_installed/ruby-1.9.2-p0.patch
+ruby extconf.rb
+make clean
+make clean install
+
+Patch was taken from http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=29242
+
+thieso@gmail.com 20101024

data/README.markdown

@@ -0,0 +1,217 @@
+Snailgun
+========
+
+Snailgun accelerates the startup of Ruby applications which require large
+numbers of libraries.  It does this by preparing a Ruby process with your
+chosen libraries preloaded, and then forking that process whenever a new
+command-line Ruby interpreter is required.
+
+Installation
+------------
+
+    sudo gem install snailgun
+
+Or for the latest code, `git clone git://github.com/candlerb/snailgun.git`
+and put the bin directory into your PATH.
+
+Case 1: standalone
+------------------
+
+    # WITHOUT SNAILGUN
+    $ time ruby -rubygems -e 'require "active_support"' -e 'puts "".blank?'
+    true
+
+    real	0m2.123s
+    user	0m1.424s
+    sys 	0m0.168s
+
+    # WITH SNAILGUN
+    $ snailgun -rubygems -ractive_support
+    Snailgun starting on /home/brian/.snailgun/14781 - 'exit' to end
+    $ time fruby -e 'puts "".blank?'
+    true
+
+    real	0m0.064s
+    user	0m0.020s
+    sys 	0m0.004s
+
+    $ exit
+    logout
+    Snailgun ended
+    $ 
+
+Case 2: Rails app
+-----------------
+
+When using Rails or Merb, snailgun will start a process preloaded for the
+`test` environment only unless told otherwise.
+
+You need to edit `config/environments/test.rb` and set
+`config.cache_classes = false`. This is so that your application classes
+are loaded each time you run a test, rather than being preloaded into
+the test environment.
+
+Snailgun will take several seconds to be ready to process requests. Start
+with `snailgun -v` if you wish to be notified when it is ready.
+
+    $ rails testapp
+    $ cd testapp
+    $ vi config/environments/test.rb
+    ... set config.cache_classes = false
+    $ snailgun
+    Now entering subshell. Use 'exit' to terminate snailgun
+
+    $ time RAILS_ENV=test fruby script/runner 'puts 1+2'
+    3
+
+    real	0m0.169s
+    user	0m0.040s
+    sys 	0m0.008s
+
+    # To run your test suite
+    $ frake test       # or frake spec
+
+Your preloaded process will remain around until you type `exit` to terminate
+it.
+
+Note that any attempt by `fruby` or `frake` to perform an action in an
+environment other than 'test' will fail.  See below for how to run multiple
+snailgun environments.
+
+Merb support has been contributed (using MERB_ENV), but it is untested by
+me.
+
+Case 3: Rails with multiple environments
+----------------------------------------
+
+After reading the warnings below, you may choose to start multiple snailgun
+processes each configured for a different environment, as follows:
+
+    $ snailgun --rails test,development
+
+This gives the potential for faster startup of rake tasks which involve
+the development environment (such as migrations) and the console. The
+utility `fconsole` is provided for this.
+
+However, beware that frake and fruby need to decide which of the preloaded
+environments to dispatch the command to.  The safest way is to force the
+correct one explicitly:
+
+    RAILS_ENV=test frake test:units
+    RAILS_ENV=development fruby script/server
+    RAILS_ENV=test fruby script/runner 'puts "".blank?'
+
+If you do not specify the environment, then a simple heuristic is used:
+
+* `fruby` always defaults to the 'development' environment.
+
+* `frake` honours any `RAILS_ENV=xxx` setting on the command line. If
+missing, `frake` defaults to the 'test' environment if no args are given or
+if an arg containing the word 'test' or 'spec' is given; otherwise it falls
+back to the 'development' environment.
+
+WARNING: The decision as to which of the preloaded environments to use is
+made *before* actually running the command.  If the wrong choice is made, it
+can lead to problems.
+
+In the worst case, you may have a 'test'-type task, but find that it is
+wrongly dispatched to your 'development' environment - and possibly ends up
+blowing away your development database.  This actually happened to me while
+developing snailgun.  SO IF YOUR DEVELOPMENT DATABASE CONTAINS USEFUL DATA,
+KEEP IT BACKED UP.
+
+If you run test files individually, it is especially critical that you set
+the correct environment. e.g.
+
+    RAILS_ENV=test fruby -Ilib -Itest test/unit/some_test.rb
+
+Case 4: Rails with cucumber
+---------------------------
+
+Cucumber creates its own Rails environment called "cucumber", so you can
+setup snailgun like this:
+
+    $ snailgun --rails test,cucumber
+
+Then use `frake cucumber` to exercise the features. frake selects the
+"cucumber" environment if run with "cucumber" as an argument.
+
+NOTE: to make your model classes be loaded on each run you need to set
+`config.cache_classes = false` in `config/environments/cucumber.rb`.
+Cucumber will give a big warning saying that this is known to be a
+problem with transactional fixtures. I don't use transactional fixtures
+so this isn't a problem for me.
+
+For a substantial performance boost, remove `:lib=>false` lines from
+`config/environments/cucumber.rb` so that cucumber, webrat, nokogiri etc
+are preloaded.
+
+Smaller performance boosts can be had from further preloading.  For example,
+cucumber makes use of some rspec libraries for diffing even if you're not
+using rspec, so you can preload those. Add something like this to the end of
+`config/environments/cucumber.rb`
+
+    begin
+      require 'spec/expectations'
+      require 'spec/runner/differs/default'
+    rescue LoadError
+    end
+    require 'test_help'
+    require 'test/unit/testresult'
+    require 'active_support/secure_random'
+    require 'active_support/time_with_zone'
+
+autotest
+--------
+
+There is some simple support for autotest (from the ZenTest package).
+Just type `fautotest` instead of `autotest` after snailgun has been started.
+This hasn't been tested for a while.
+
+Bypassing rubygems
+------------------
+
+You can get noticeably faster startup if you don't use rubygems to invoke
+the programs.  To do this, you can add the binary directory directly into
+the front of your PATH, e.g. for Ubuntu
+
+    PATH=/var/lib/gems/1.8/gems/snailgun-1.0.3/bin:$PATH
+
+Alternatively, create a file called `fruby` somewhere early on in your PATH
+(e.g. under `$HOME/bin`), like this:
+
+    #!/usr/bin/env ruby
+    load '/path/to/the/real/fruby'
+
+Repeat for `frake` etc.
+
+Other bugs and limitations
+--------------------------
+Only works with Linux/BSD systems, due to use of passing open file
+descriptors across a socket.
+
+Ctrl-C doesn't terminate frake processes.
+
+`fruby script/console` doesn't give any speedup, because script/console uses
+exec to invoke irb.  Use the supplied `fconsole` instead.
+
+The environment is not currently passed across the socket to the ruby
+process. This means it's not usable as a fast CGI replacement.
+
+In Rails, you need to beware that any changes to your `config/environment*`
+will not be reflected until you stop and restart snailgun.
+
+Licence
+-------
+This code is released under the same licence as Ruby itself.
+
+Author
+------
+Brian Candler <B.Candler@pobox.com>
+
+Credits:
+
+* Jan X <jan.h.xie@gmail.com>
+* George Ogata <george.ogata@gmail.com>
+* Niklas Hofer <niklas+dev@lanpartei.de>
+* Thies C. Arntzen <thieso@gmail.com>

data/bin/fautotest

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+# shortcut for: RAILS_ENV=test fruby /path/to/autotest
+
+ENV["RAILS_ENV"] = "test"
+Test::Unit.run = true if defined?(Test::Unit) && Test::Unit.respond_to?(:run=)
+ARGV[0,0] = ["-e","gem 'ZenTest'","-e","load Gem.bin_path('ZenTest', 'autotest')","--"]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fconsole

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+ENV['RAILS_ENV'] = ARGV.shift if ARGV[0] =~ /^\w/
+
+ARGV[0,0] = [
+  "-rirb",
+  "-rirb/completion",
+  "-rconsole_app",
+  "-rconsole_with_helpers",
+  "-eIRB.start", "--", "--simple-prompt"
+]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fcucumber

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+$DEFAULT_ENV='cucumber'
+ARGV[0,0] = ['cucumber']
+load File.join(File.dirname(__FILE__), 'fruby')

data/bin/frake

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+# Here we run rake within a pre-forked ruby process
+
+# Pre-parse environment - see collect_tasks in rake/lib/rake.rb
+ARGV.each do |arg|
+  if arg =~ /^(\w+)=(.*)$/
+    ENV[$1] = $2
+  end
+end
+
+# Rails/Merb: make a guess at the correct environment
+if File.exist?("config/boot.rb") || File.exist?("config/init.rb")
+  if ARGV.find { |arg| arg =~ /\bcucumber\b/ }
+    $DEFAULT_ENV='cucumber'
+  elsif ARGV.find { |arg| arg =~ /\b(test|spec)\b/ } || !ARGV.find { |arg| arg !~ /^-/ }
+    $DEFAULT_ENV='test'
+  end
+end
+
+ARGV[0,0] = ["-rrake", "-eRake.application.run", "--"]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fruby

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+# This could be rewritten in C for even faster startup
+
+require 'lib/snailgun/client'
+
+if ENV['SNAILGUN_SOCK']
+  sockname = ENV['SNAILGUN_SOCK']
+elsif File.directory?('tmp/sockets/snailgun')
+  env = ENV['RAILS_ENV'] || ENV['MERB_ENV']
+  unless env
+    # Normally default to development: see railties/lib/tasks/misc.rake
+    env = $DEFAULT_ENV || 'development'
+    STDERR.puts "Snailgun assuming environment '#{env}'"
+  end
+  sockname = "tmp/sockets/snailgun/#{env}"
+end
+
+unless sockname and File.exists? sockname
+  STDERR.puts <<EOS
+Unable to find path to snailgun socket.
+- did you run this in a session with a snailgun parent?
+- you can do 'SNAILGUN_SOCK=/path/to/sock #{$0} ...'
+EOS
+  exit 1
+end
+
+Snailgun::Client.new(sockname)

data/bin/snailgun

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+# Turn on copy-on-write garbage collection in REE: see
+# http://www.rubyenterpriseedition.com/documentation.html#_copy_on_write_friendliness
+begin
+  GC.copy_on_write_friendly = true
+rescue NoMethodError
+end
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'snailgun/server'
+require 'optparse'
+
+sockpath = nil
+mode = nil
+envs = "test"
+rake = false
+verbose = false
+
+def fix_rake
+  require 'rbconfig'
+  Config::CONFIG['bindir'] = File.expand_path(File.dirname(__FILE__))
+  Config::CONFIG['ruby_install_name'] = 'fruby'
+  require 'rubygems'
+  require 'rake'
+  require 'rake/testtask'
+  require 'rake/rdoctask'
+end
+
+OptionParser.new do |opts|
+  opts.on("-I DIR", "add to load path")		{ |v| $:.unshift v }
+  opts.on("-r LIB", "require library")		{ |v| require v }
+  opts.on("--rails [ENVS]", "rails mode")	{ |v| mode = :rails; envs = v }
+  opts.on("--ruby [SOCKPATH]", "ruby mode")	{ |v| mode = :ruby; sockpath = v }
+  opts.on("--rake", "add rake support")		{ rake = true }
+  opts.on("-v", "--verbose", "show progress")	{ verbose = true }
+end.parse!
+
+mode ||= if File.exist?("config/boot.rb")
+           :rails
+         elsif File.exist?("config/init.rb")
+           :merb
+         else
+           :ruby
+         end
+
+STDERR.puts "Starting in #{mode} mode" if verbose
+case mode
+when :ruby
+  unless sockpath
+    dir = File.join(ENV['HOME'], '.snailgun')
+    begin
+      Dir.mkdir dir, 0700
+    rescue Errno::EEXIST
+      File.chmod 0700, dir
+    end
+    sockpath = File.join dir, $$.to_s
+  end
+  fix_rake if rake
+  server = Snailgun::Server.new(sockpath)
+  server.interactive!
+
+when :rails
+  conf = File.expand_path('config/boot.rb')
+  unless File.exist?(conf)
+    raise "#{conf} does not exist, cannot continue"
+  end
+  sockdir = File.expand_path('tmp/sockets/snailgun')
+  begin
+    Dir.mkdir sockdir, 0700
+  rescue Errno::EEXIST
+    File.chmod 0700, sockdir
+  end
+  pids = {}
+  fix_rake   # TODO: separate process for rake (but then need to choose right RAILS_ENV)
+  
+  start_for_envs = envs.split(/[\s,]+/).uniq
+  start_for_envs.each do |env|
+    pids[env] = fork do
+      STDERR.puts "Server starting for RAILS_ENV=#{env}"
+      server = Snailgun::Server.new("#{sockdir}/#{env}")
+      ENV['RAILS_ENV'] = env
+      load conf
+
+      if File.exist?('./.snailgun.preload')
+        require 'snailgun/require_preload'
+      else
+        puts "please create a .snailgun.preload by ..."
+      end
+
+      if Rails.respond_to?(:configuration) && Rails.configuration.cache_classes
+        STDERR.puts <<-EOS
+WARNING: Snailgun doesn't work well with `cache_classes`. Strongly recommend
+`config.cache_classes = false` in config/environments/#{env}.rb
+EOS
+      end
+      STDERR.puts "Server ready for RAILS_ENV=#{env}"
+      server.run
+    end
+  end
+  if start_for_envs.size == 1
+    ENV['RAILS_ENV'] = start_for_envs.first
+    STDERR.puts "Now entering subshell for RAILS_ENV=#{ENV['RAILS_ENV']}. Use 'exit' to terminate snailgun"
+  else
+    STDERR.puts "Now entering subshell Don't forget to set your RAILS_ENV!. Use 'exit' to terminate snailgun"
+  end
+  Snailgun::Server.shell
+  pids.each do |env,pid|
+    Process.kill('TERM',pid)
+  end
+  # TODO: wait a few secs for them to die, 'KILL' if required
+  STDERR.puts "Snailgun ended"
+
+when :merb
+  conf = File.expand_path('config/init.rb')
+  unless File.exist?(conf)
+    raise '#{conf} does not exist, cannot continue'
+  end
+  sockdir = File.expand_path('tmp/sockets/snailgun')
+  begin
+    require 'fileutils'
+    FileUtils.mkdir_p sockdir
+  ensure
+    File.chmod 0700, sockdir
+  end
+  pids = {}
+  fix_rake   # TODO: separate process for rake (but then need to choose right RAILS_ENV)
+  envs.split(/\s*,\s*/).uniq.each do |env|
+    pids[env] = fork do
+      server = Snailgun::Server.new("#{sockdir}/#{env}")
+      ENV['MERB_ENV'] = env
+
+      require 'rubygems'
+      gem 'merb-core'
+      require 'merb'
+      Merb.start_environment([env])
+
+      STDERR.puts "Started server for #{env}" if verbose
+      server.run
+    end
+  end
+  STDERR.puts "Use 'exit' to terminate snailgun"
+  Snailgun::Server.shell
+  pids.each do |env,pid|
+    Process.kill('TERM',pid)
+  end
+  # TODO: wait a few secs for them to die, 'KILL' if required
+  STDERR.puts "Snailgun ended"
+end

data/bin/snailgun_ruby

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'snailgun/client'
+
+def rvm_env(path)
+  if File.exist?(file = "#{path}/.rvmrc")
+    ruby, gemset = IO.read(file).strip.split(" ").last.split("@")
+    Dir["#{ENV['rvm_path']}/environments/*#{ruby}*@#{gemset}"].first
+  elsif path != "/"
+    rvm_env(File.expand_path("#{path}/../"))
+  end
+end
+
+def snailgun_socket(path)
+  if File.socket?(socket = "#{path}/tmp/sockets/snailgun/test")
+    socket
+  elsif path != "/"
+    snailgun_socket(File.expand_path("#{path}/../"))
+  end
+end
+
+def skip_snailgun?
+  ARGV.size == 1 && ARGV[0] =~ /^\/tmp\/cucumber/
+end
+
+def log(msg)
+  File.open("/tmp/snailgun_ruby.log", "a+") { |f| f.puts msg }
+end
+
+cwd = Dir.pwd
+
+if !skip_snailgun? && (socket = snailgun_socket(cwd))
+  log "fruby #{ARGV.inspect}"
+  Snailgun::Client.new(socket)
+else 
+  if rvm_env = rvm_env(cwd)
+    require 'shellwords'
+    args = ARGV.map { |a| Shellwords.shellescape(a) }.join(" ")
+    log "exec:bash -c 'source #{rvm_env}; ruby #{args}'"
+    Kernel.exec('bash', "-c", "source #{rvm_env}; ruby #{args}")
+  else
+    log "exec:ruby #{ARGV.inspect}\""
+    Kernel.exec('ruby', *ARGV)
+  end
+end

data/lib/snailgun/client.rb

@@ -0,0 +1,21 @@
+require 'socket'
+module Snailgun
+  class Client
+    def initialize(sockname)
+      server = UNIXSocket.open(sockname)
+      server.send_io(STDIN)
+      server.send_io(STDOUT)
+      server.send_io(STDERR)
+      args = Marshal.dump([ARGV, ENV.to_hash, Dir.pwd, Process.getpgrp])
+      server.write [args.size].pack("N")
+      server.write args
+      begin
+        rc = (server.read(1) || "\000").unpack("C").first
+        exit rc
+      rescue Interrupt
+        server.write('X')
+        exit 1
+      end
+    end
+  end
+end

data/lib/snailgun/require_preload.rb

@@ -0,0 +1,11 @@
+ignore = File.exist?(".snailgun.ignore") ? IO.read(".snailgun.ignore").split : []
+(IO.read(".snailgun.preload") rescue '').split.each do |path|
+  next if ignore.include?(path)
+  next if path =~ /^#/
+  puts "snailgun.preload: #{path}"
+  begin
+    require path
+  rescue Exception => e
+    puts "cannot preload:'#{path}' 'cause of:#{e.message}"
+  end
+end

data/lib/snailgun/require_timings.rb

@@ -0,0 +1,48 @@
+require 'benchmark'
+
+$require_level = 0
+$required = []
+
+class SnailgunPreloader
+  @@preload_file = "#{File.expand_path(Dir.pwd)}/.snailgun.preload"
+  
+  class << self
+    def load_file(path)
+      File.exist?(path) ? IO.read(path).split : []
+    end
+    
+    def add_to_preload(path)
+      ignore = load_file(".snailgun.ignore")
+      already_marked_for_preloading = load_file(@@preload_file)
+      unless ignore.include?(path) || already_marked_for_preloading.include?(path)
+        puts "adding #{path}"
+        File.open(@@preload_file, "a+") { |f| f.puts path }
+      end
+    end
+  end
+end
+
+module Kernel
+  alias require_without_timing require
+  def require(path)
+    result = seconds = nil
+    
+    begin
+      $require_level += 1 
+      seconds = Benchmark.realtime { result = require_without_timing(path) }
+    ensure
+      $require_level -= 1 
+    end
+
+   if result == true && $require_level == 0
+     SnailgunPreloader.add_to_preload(path)
+   end
+
+#    if result
+#      puts "R:#{'%.5f' % seconds} #{' '*$require_level}#{path} "  
+#    end
+
+    result
+  end
+end
+

data/lib/snailgun/server.rb

@@ -0,0 +1,132 @@
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+# Our at_exit handler must be called *last*, so register it first
+at_exit { $SNAILGUN_EXIT.call if $SNAILGUN_EXIT }
+
+# Fix truncation of $0. See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/336743
+$progname = $0
+alias $PROGRAM_NAME $0
+alias $0 $progname
+trace_var(:$0) {|val| $PROGRAM_NAME = val} # update for ps
+
+require 'socket'
+require 'optparse'
+require 'shellwords'
+
+module Snailgun
+  class Server
+    attr_accessor :sockname
+
+    def initialize(sockname = nil)
+      @sockname = sockname || "/tmp/snailgun#{$$}"
+      File.delete(@sockname) rescue nil
+      @socket = UNIXServer.open(@sockname)
+      yield self if block_given?
+    end
+
+    def run
+      while client = @socket.accept
+        pid = fork do
+          rubylib = nil
+          begin
+            STDIN.reopen(client.recv_io)
+            STDOUT.reopen(client.recv_io)
+            STDERR.reopen(client.recv_io)
+            nbytes = client.read(4).unpack("N").first
+            args, env, cwd, pgid = Marshal.load(client.read(nbytes))
+            Dir.chdir(cwd)
+            if rubylib = env['RUBYLIB']
+              rubylib.split(/:/).each do |path| 
+                $LOAD_PATH.unshift path
+              end
+            end
+            begin
+              Process.setpgid(0, pgid)
+            rescue Errno::EPERM
+            end
+            exit_status = 0
+            $SNAILGUN_EXIT = lambda {
+              begin
+                client.write [exit_status].pack("C")
+              rescue Errno::EPIPE
+              end
+            }
+            #This doesn't work in 1.8.6:
+            #Thread.new { client.read(1); Thread.main.raise Interrupt }
+            Thread.new { client.read(1); exit 1 }
+            start_ruby(args)
+          rescue SystemExit => e
+            exit_status = e.status
+            raise  # for the benefit of Test::Unit
+          rescue Exception => e
+            STDERR.puts "#{e}\n\t#{e.backtrace.join("\n\t")}"
+            exit 1
+          ensure
+            $LOAD_PATH.shift if rubylib
+          end
+        end
+        Process.detach(pid) if pid && pid > 0
+        client.close
+      end
+    ensure
+      File.delete(@sockname) rescue nil
+    end
+
+    # Process the received ruby command line. (TODO: implement more options)
+    def start_ruby(args)
+      e = []
+      OptionParser.new do |opts|
+        opts.on("-e EXPR") do |v|
+          e << v
+        end
+        opts.on("-I DIR") do |v|
+          v.split(/:/).each do |path|
+            $:.unshift path
+          end
+        end
+        opts.on("-r LIB") do |v|
+          require v
+        end
+        opts.on("--dump_requires") do |v|
+          require File.dirname(__FILE__) + "/require_timings.rb"
+        end
+        opts.on("-KU") do |v|
+          $KCODE = 'u' if RUBY_VERSION < "1.9"
+        end
+      end.order!(args)
+
+      ARGV.replace(args)
+      if !e.empty?
+        $0 = '-e'
+        e.each { |expr| eval(expr, TOPLEVEL_BINDING) }
+      elsif ARGV.empty?
+        $0 = '-'
+        eval(STDIN.read, TOPLEVEL_BINDING)
+      else
+        cmd = ARGV.shift
+        $0 = cmd
+        load(cmd)
+      end
+    end
+    
+    def self.shell
+      shell_opts = ENV['SNAILGUN_SHELL_OPTS']
+      args = shell_opts ? Shellwords.shellwords(shell_opts) : []
+      system(ENV['SHELL'] || 'bash', *args)
+    end
+
+    # Interactive mode (start a subshell with SNAILGUN_SOCK set up,
+    # and terminate the snailgun server when the subshell exits)
+    def interactive!
+      ENV['SNAILGUN_SOCK'] = @sockname
+      pid = Process.fork {
+        STDERR.puts "Snailgun starting on #{sockname} - 'exit' to end"
+        run
+      }
+      self.class.shell
+      Process.kill('TERM',pid)
+      # TODO: wait a few secs for it to die, 'KILL' if required
+      STDERR.puts "Snailgun ended"
+    end
+  end
+end

data/ruby-1.9.2-p0.patch

@@ -0,0 +1,54 @@
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: Makefile
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: ancdata.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: basicsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constants.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constdefs.c
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constdefs.h
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: extconf.h
+diff -u socket/extconf.rb /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/extconf.rb
+--- socket/extconf.rb	2010-05-19 15:48:50.000000000 +0200
++++ /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/extconf.rb	2010-10-24 10:44:17.000000000 +0200
+@@ -117,7 +117,7 @@
+   }
+ end
+ 
+-if (have_func("sendmsg") | have_func("recvmsg")) && /64-darwin/ !~ RUBY_PLATFORM
++if have_func("sendmsg") | have_func("recvmsg")
+   # CMSG_ macros are broken on 64bit darwin, because of use of __DARWIN_ALIGN.
+   have_struct_member('struct msghdr', 'msg_control', ['sys/types.h', 'sys/socket.h'])
+   have_struct_member('struct msghdr', 'msg_accrights', ['sys/types.h', 'sys/socket.h'])
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: init.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: ipsocket.o
+Common subdirectories: socket/lib and /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/lib
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: mkmf.log
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: option.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: raddrinfo.o
+diff -u socket/rubysocket.h /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/rubysocket.h
+--- socket/rubysocket.h	2010-04-28 09:16:30.000000000 +0200
++++ /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/rubysocket.h	2010-10-24 10:43:51.000000000 +0200
+@@ -138,6 +138,17 @@
+ };
+ #endif
+ 
++#if defined __APPLE__ && defined __MACH__
++/*
++ * CMSG_ macros are broken on 64bit darwin, because __DARWIN_ALIGN
++ * aligns up to __darwin_size_t which is 64bit, but CMSG_DATA is
++ * 32bit-aligned.
++ */
++#undef __DARWIN_ALIGNBYTES
++#define __DARWIN_ALIGNBYTES (sizeof(unsigned int) - 1)
++#endif
++
++
+ #if defined(_AIX)
+ #ifndef CMSG_SPACE
+ # define CMSG_SPACE(len) (_CMSG_ALIGN(sizeof(struct cmsghdr)) + _CMSG_ALIGN(len))
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: socket.bundle
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: socket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: sockssocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: tcpserver.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: tcpsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: udpsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: unixserver.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: unixsocket.o

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: tmp8-snailgun
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 2
+  - 0
+  version: 1.2.0
+platform: ruby
+authors: 
+- Brian Candler
+- Sebastian Korfmann
+- Thies C. Arntzen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-01 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Snailgun accelerates the startup of Ruby applications which require large numbers of libraries
+email: 
+- b.candler@pobox.com
+- dev@tmp8.de
+executables: 
+- fautotest
+- fconsole
+- fcucumber
+- frake
+- fruby
+- snailgun
+- snailgun_ruby
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- bin/fautotest
+- bin/fconsole
+- bin/fcucumber
+- bin/frake
+- bin/fruby
+- bin/snailgun
+- bin/snailgun_ruby
+- lib/snailgun/server.rb
+- lib/snailgun/require_timings.rb
+- lib/snailgun/client.rb
+- lib/snailgun/require_preload.rb
+- README.markdown
+- README-snowleopard
+- ruby-1.9.2-p0.patch
+has_rdoc: true
+homepage: http://github.com/candlerb/snailgun
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: snailgun
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: Command-line startup accelerator
+test_files: []
+