snailgun 1.0.3

data/README.markdown

@@ -0,0 +1,177 @@
+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 sources -a http://gems.github.com/
+    sudo gem install candlerb-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
+    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
+
+autotest
+--------
+
+There is some simple support for autotest (from the ZenTest package).
+Just type `fautotest` instead of `autotest` after snailgun has been started.
+
+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.2/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>

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 '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/frake

@@ -0,0 +1,19 @@
+#!/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
+
+# Make a guess at the correct environment
+if File.exist?("config/boot.rb") || File.exist?("config/init.rb")
+  # Rails: default task is 'test'
+  $DEFAULT_ENV='test' if ARGV.find { |arg| arg =~ /\b(test|spec)\b/ } || !ARGV.find { |arg| arg !~ /^-/ }
+end
+
+ARGV[0,0] = ["-rrake", "-eRake.application.run", "--"]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fruby

@@ -0,0 +1,40 @@
+#!/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 'socket'
+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
+  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
+
+server = UNIXSocket.open(sockname)
+server.send_io(STDIN)
+server.send_io(STDOUT)
+server.send_io(STDERR)
+args = Marshal.dump([ARGV, 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

data/bin/snailgun

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+$:.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)
+  envs.split(/[\s,]+/).uniq.each do |env|
+    pids[env] = fork do
+      server = Snailgun::Server.new("#{sockdir}/#{env}")
+      ENV['RAILS_ENV'] = env
+      load conf
+      require File.expand_path(RAILS_ROOT + '/config/environment')
+      # We can get some drastic test speedups by preloading test frameworks
+      if env != 'test'
+        # do nothing
+      elsif File.exist?('test/test_helper.rb')
+        require 'test_help'
+      elsif File.exist?('spec/spec_helper.rb')
+        require 'spec'
+        require 'spec/rails'
+      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 "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"
+
+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/lib/snailgun/server.rb

@@ -0,0 +1,112 @@
+# 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'
+
+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
+        fork do
+          begin
+            STDIN.reopen(client.recv_io)
+            STDOUT.reopen(client.recv_io)
+            STDERR.reopen(client.recv_io)
+            nbytes = client.read(4).unpack("N").first
+            args, cwd, pgid = Marshal.load(client.read(nbytes))
+            Dir.chdir(cwd)
+            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
+          end
+        end
+        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|
+          $:.unshift v
+        end
+        opts.on("-r LIB") do |v|
+          require v
+        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
+      system(ENV['shell'] || 'bash')
+    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

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: snailgun
+version: !ruby/object:Gem::Version 
+  version: 1.0.3
+platform: ruby
+authors: 
+- Brian Candler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-19 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
+executables: 
+- fautotest
+- fconsole
+- frake
+- fruby
+- snailgun
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- bin/fautotest
+- bin/fconsole
+- bin/frake
+- bin/fruby
+- bin/snailgun
+- lib/snailgun/server.rb
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/candlerb/snailgun
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: snailgun
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Command-line startup accelerator
+test_files: []
+