rails_product 0.5

data/bin/listener

@@ -0,0 +1,86 @@
+#!/usr/local/bin/ruby
+
+require 'stringio'
+require 'fileutils'
+require 'fcgi_handler'
+
+def message(s)
+  $stderr.puts "listener: #{s}" if ENV && ENV["DEBUG_GATEWAY"]
+end
+
+class RemoteCGI < CGI
+  attr_accessor :stdinput, :stdoutput, :env_table
+  def initialize(env_table, input = nil, output = nil)
+    self.env_table = env_table
+    self.stdinput = input || StringIO.new
+    self.stdoutput = output || StringIO.new
+    super()
+  end
+
+  def out(stream) # Ignore the requested output stream
+    super(stdoutput)
+  end
+end
+
+class Listener
+  include DRbUndumped
+
+  def initialize(timeout, socket_path)
+    @socket = File.expand_path(socket_path)
+    @mutex = Mutex.new
+    @active = false
+    @timeout = timeout
+
+    @handler = RailsFCGIHandler.new
+    @handler.extend DRbUndumped
+
+    message 'opening socket'
+    DRb.start_service("drbunix:#{@socket}", self)
+
+    message 'entering process loop'
+    @handler.process! self
+  end
+
+  def each_cgi(&cgi_block)
+    @cgi_block = cgi_block
+    message 'entering idle loop'
+    loop do
+      sleep @timeout rescue nil
+      die! unless @active
+      @active = false
+    end
+  end
+
+  def process(env, input)
+    message 'received request'
+    @mutex.synchronize do
+      @active = true
+
+      message 'creating input stream'
+      input_stream = StringIO.new(input)
+      message 'building CGI instance'
+      cgi = RemoteCGI.new(eval(env), input_stream)
+
+      message 'yielding to fcgi handler'
+      @cgi_block.call cgi
+      message 'yield finished -- sending output'
+
+      cgi.stdoutput.seek(0)
+      output = cgi.stdoutput.read
+
+      return output
+    end
+  end
+
+  def die!
+    message 'shutting down'
+    DRb.stop_service
+    FileUtils.rm_f @socket
+    Kernel.exit 0
+  end
+end
+
+socket_path = ARGV.shift
+timeout = (ARGV.shift || 90).to_i
+
+Listener.new(timeout, socket_path)

data/bin/process/reaper

@@ -0,0 +1,123 @@
+#!/usr/local/bin/ruby
+
+require 'optparse'
+require 'net/http'
+require 'uri'
+
+def nudge(url, iterations)
+  print "Nudging #{url}: "
+  iterations.times {  Net::HTTP.get_response(URI.parse(url)); print "."; STDOUT.flush }
+  puts
+end
+
+if RUBY_PLATFORM =~ /mswin32/ then abort("Reaper is only for Unix") end
+
+class ProgramProcess
+  class << self
+    def process_keywords(action, *keywords)
+      processes = keywords.collect { |keyword| find_by_keyword(keyword) }.flatten
+
+      if processes.empty?
+        puts "Couldn't find any process matching: #{keywords.join(" or ")}"
+      else
+        processes.each do |process|
+          puts "#{action.capitalize}ing #{process}"
+          process.send(action)
+        end
+      end      
+    end
+
+    def find_by_keyword(keyword)
+      process_lines_with_keyword(keyword).split("\n").collect { |line|
+        next if line.include?("inq") || line.include?("ps -ax") || line.include?("grep")
+        pid, *command = line.split
+        new(pid, command.join(" "))
+      }.compact
+    end
+
+    private
+      def process_lines_with_keyword(keyword)
+        `ps -ax -o 'pid command' | grep #{keyword}`
+      end
+  end
+
+  def initialize(pid, command)
+    @pid, @command = pid, command
+  end
+
+  def find
+  end
+
+  def reload
+    `kill -s HUP #{@pid}`
+  end
+
+  def graceful
+    `kill -s TERM #{@pid}`
+  end
+
+  def kill
+    `kill -9 #{@pid}`
+  end
+
+  def to_s
+    "[#{@pid}] #{@command}"
+  end
+end
+
+OPTIONS = {
+  :action     => "graceful",
+  :dispatcher => File.expand_path(File.dirname(__FILE__) + '/../../public/dispatch.fcgi'),
+  :iterations => 10,
+  :nudge      => false
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: reaper [options]"
+
+  opts.separator ""
+
+  opts.on <<-EOF
+  Description:
+    The reaper is used to reload, gracefully exit, and forcefully exit FCGI processes
+    running a Rails Dispatcher. This is commonly done when a new version of the application
+    is available, so the existing processes can be updated to use the latest code.
+
+    The reaper actions are:
+
+    * reload  : Only reloads the application, but not the framework (like the development environment)
+    * graceful: Marks all of the processes for exit after the next request
+    * kill    : Forcefully exists all processes regardless of whether they're currently serving a request
+
+    Graceful exist is the most common and default action. But since the processes won't exist until after
+    their next request, it's often necessary to ensure that such a request occurs right after they've been
+    marked. That's what nudging is for. 
+
+    A nudge is simply a request to a URL where the dispatcher is serving. You should perform one nudge per
+    FCGI process you have running if they're setup in a round-robin. Be sure to do one nudge per FCGI process
+    across all your servers. So three servers with 10 processes each should nudge 30 times to be sure all processes
+    are restarted.
+    
+    NOTE: You're responsible for restarting the processes after they exit. This can be automated by using
+    the spinner.
+  Examples:
+    reaper -a reload
+    reaper -n http://www.example.com -i 10 # gracefully exit, nudge 10 times
+  EOF
+
+  opts.on("  Options:")
+
+  opts.on("-a", "--action=name", "reload|graceful|kill (default: #{OPTIONS[:action]})", String)  { |OPTIONS[:action]| }
+  opts.on("-d", "--dispatcher=path", "default: #{OPTIONS[:dispatcher]}", String)                 { |OPTIONS[:dispatcher]| }
+  opts.on("-n", "--nudge=url", "Should point to URL that's handled by the FCGI process", String) { |OPTIONS[:nudge]| }
+  opts.on("-i", "--iterations=number", "One nudge per FCGI process running (default: #{OPTIONS[:iterations]})", Integer) { |OPTIONS[:iterations]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])
+nudge(OPTIONS[:nudge], OPTIONS[:iterations]) if OPTIONS[:nudge]

data/bin/process/spawner

@@ -0,0 +1,54 @@
+#!/usr/local/bin/ruby
+
+require 'optparse'
+
+def spawn(port)
+  print "Starting FCGI on port: #{port}\n  "
+  system("#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port}")
+end
+
+OPTIONS = {
+  :environment => "production",
+  :spawner     => '/usr/bin/env spawn-fcgi',
+  :dispatcher  => File.expand_path(File.dirname(__FILE__) + '/../../public/dispatch.fcgi'),
+  :port        => 8000,
+  :instances   => 3
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: spawner [options]"
+
+  opts.separator ""
+
+  opts.on <<-EOF
+  Description:
+    The spawner is a wrapper for spawn-fcgi that makes it easier to start multiple FCGI
+    processes running the Rails dispatcher. The spawn-fcgi command is included with the lighttpd 
+    web server, but can be used with both Apache and lighttpd (and any other web server supporting
+    externally managed FCGI processes).
+
+    You decide a starting port (default is 8000) and the number of FCGI process instances you'd 
+    like to run. So if you pick 9100 and 3 instances, you'll start processes on 9100, 9101, and 9102.
+
+  Examples:
+    spawner               # starts instances on 8000, 8001, and 8002
+    spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to 9109
+  EOF
+
+  opts.on("  Options:")
+
+  opts.on("-p", "--port=number", Integer, "Starting port number (default: #{OPTIONS[:port]})")                   { |OPTIONS[:port]| }
+  opts.on("-i", "--instances=number", Integer, "Number of instances (default: #{OPTIONS[:instances]})")          { |OPTIONS[:instances]| }
+  opts.on("-e", "--environment=name", String, "test|development|production (default: #{OPTIONS[:environment]})") { |OPTIONS[:environment]| }
+  opts.on("-s", "--spawner=path",    String, "default: #{OPTIONS[:spawner]}")                                    { |OPTIONS[:spawner]| }
+  opts.on("-d", "--dispatcher=path", String, "default: #{OPTIONS[:dispatcher]}") { |dispatcher| OPTIONS[:dispatcher] = File.expand_path(dispatcher) }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = OPTIONS[:environment]
+OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }

data/bin/process/spinner

@@ -0,0 +1,60 @@
+#!/usr/local/bin/ruby
+
+require 'optparse'
+
+def daemonize
+  exit if fork                   # Parent exits, child continues.
+  Process.setsid                 # Become session leader.
+  exit if fork                   # Zap session leader. See [1].
+  Dir.chdir "/"                  # Release old working directory.
+  File.umask 0000                # Ensure sensible umask. Adjust as needed.
+  STDIN.reopen "/dev/null"       # Free file descriptors and
+  STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
+  STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
+end
+
+OPTIONS = {
+  :interval   => 1.0,
+  :command    => File.expand_path(File.dirname(__FILE__) + '/spawner'),
+  :daemon     => false
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: spinner [options]"
+
+  opts.separator ""
+
+  opts.on <<-EOF
+  Description:
+    The spinner is a protection loop for the spawner, which will attempt to restart any FCGI processes
+    that might have been restarted or outright crashed. It's a brute-force attempt that'll just try
+    to run the spawner every X number of seconds, so it does pose a load on the server (~1% on our test
+    server).    
+
+  Examples:
+    spinner # attempts to run the spawner with default settings every second with output on the terminal
+    spinner -i 3 -d # only run the spawner every 3 seconds and detach from the terminal to become a daemon
+    spinner -c '/path/to/app/script/process/spawner -p 9000 -i 10' -d # using custom spawner
+  EOF
+
+  opts.on("  Options:")
+
+  opts.on("-c", "--command=path",    String) { |OPTIONS[:command]| }
+  opts.on("-i", "--interval=seconds", Float) { |OPTIONS[:interval]| }
+  opts.on("-d", "--daemon")                  { |OPTIONS[:daemon]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+daemonize if OPTIONS[:daemon]
+
+loop do
+  system(OPTIONS[:command])
+  sleep(OPTIONS[:interval])
+end
+
+trap(OPTIONS[:daemon] ? "TERM" : "INT") { exit }

data/bin/profiler

@@ -0,0 +1,34 @@
+#!/usr/local/bin/ruby
+if ARGV.empty?
+  $stderr.puts "Usage: profiler 'Person.expensive_method(10)' [times]"
+  exit(1)
+end
+
+# Keep the expensive require out of the profile.
+$stderr.puts 'Loading Rails...'
+require File.dirname(__FILE__) + '/../config/environment'
+
+# Define a method to profile.
+if ARGV[1] and ARGV[1].to_i > 1
+  eval "def profile_me() #{ARGV[1]}.times { #{ARGV[0]} } end"
+else
+  eval "def profile_me() #{ARGV[0]} end"
+end
+
+# Use the ruby-prof extension if available.  Fall back to stdlib profiler.
+begin
+  require 'prof'
+  $stderr.puts 'Using the ruby-prof extension.'
+  Prof.clock_mode = Prof::GETTIMEOFDAY
+  Prof.start
+  profile_me
+  results = Prof.stop
+  require 'rubyprof_ext'
+  Prof.print_profile(results, $stderr)
+rescue LoadError
+  $stderr.puts 'Using the standard Ruby profiler.'
+  Profiler__.start_profile
+  profile_me
+  Profiler__.stop_profile
+  Profiler__.print_profile($stderr)
+end

data/bin/rails

@@ -0,0 +1,17 @@
+min_release  = "1.8.2 (2004-12-25)"
+ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+if ruby_release < min_release
+  abort <<-end_message
+
+    Rails requires Ruby version #{min_release} or later.
+    You're running #{ruby_release}; please upgrade to continue.
+
+  end_message
+end
+
+Signal.trap("INT") { puts; exit }
+
+require File.dirname(__FILE__) + '/../lib/rails_generator'
+require 'rails_generator/scripts/generate'
+Rails::Generator::Base.use_application_sources!
+Rails::Generator::Scripts::Generate.new.run(ARGV, :generator => 'app')

data/bin/rails_product

@@ -0,0 +1,17 @@
+min_release  = "1.8.2 (2004-12-25)"
+ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+if ruby_release < min_release
+  abort <<-end_message
+
+    Rails requires Ruby version #{min_release} or later.
+    You're running #{ruby_release}; please upgrade to continue.
+
+  end_message
+end
+
+Signal.trap("INT") { puts; exit }
+
+require File.dirname(__FILE__) + '/../lib/rails_generator'
+require 'rails_generator/scripts/generate'
+Rails::Generator::Base.use_application_sources!
+Rails::Generator::Scripts::Generate.new.run(ARGV, :generator => 'productized_app')

data/bin/runner

@@ -0,0 +1,28 @@
+require 'optparse'
+
+options = { :environment => "development" }
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: runner 'puts Person.find(1).name' [options]"
+
+  opts.separator ""
+
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment for the runner to operate under (test/development/production).",
+          "Default: development") { |options[:environment]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = options[:environment]
+
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + '/../config/environment'
+eval(ARGV.first)

data/bin/server

@@ -0,0 +1,125 @@
+#!/opt/local/bin/ruby
+
+require 'webrick'
+require 'optparse'
+
+OPTIONS = {
+  :port        => 3000,
+  :ip          => "0.0.0.0",
+  :environment => "development",
+  :server_root => File.expand_path(File.dirname(__FILE__) + "/../public/"),
+  :server_type => WEBrick::SimpleServer,
+  :site        => nil
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: ruby #{script_name} [options]"
+
+  opts.separator ""
+
+  opts.on("-s", "--site=name", String,
+          "Specifies the site that this server will run.",
+          "Default: none (required)") { |OPTIONS[:site]| }
+  opts.on("-p", "--port=port", Integer,
+          "Runs Rails on the specified port.",
+          "Default: 3000") { |OPTIONS[:port]| }
+  opts.on("-b", "--binding=ip", String,
+          "Binds Rails to the specified ip.",
+          "Default: 0.0.0.0") { |OPTIONS[:ip]| }
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |OPTIONS[:environment]| }
+  opts.on("-d", "--daemon",
+          "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
+          ) { OPTIONS[:server_type] = WEBrick::Daemon }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["SITE"] = OPTIONS[:site] if OPTIONS[:site]
+ENV["RAILS_ENV"] = OPTIONS[:environment]
+require File.dirname(__FILE__) + "/../config/environment"
+if not defined? SITE or SITE.nil? or SITE.empty?
+  puts "=> The SITE environment variable was not set."
+  site_dir = Dir.new(File.join(RAILS_ROOT, 'sites'))
+  sites = []
+  site_dir.each do |d|
+    sites << d if File.directory?(File.join(RAILS_ROOT, 'sites', d)) and d != "." and d != ".."
+  end
+  if sites.size > 0
+    puts "  According to your sites/ folder, you can set SITE to one of the following:"
+    sites.each { |d| puts "   - #{d}" }
+    puts "  So, for example you could start the server with:"
+    puts "     './script/server -s #{sites.first}'"
+  else
+    puts "  It appears that you do not yet have any sites to choose from.  You will need"
+    puts "  at least one site in your sites/ folder.  The best way to start is to use the"
+    puts "  site generator (http://wiki.rubyonrails.com/rails/show/AvailableGenerators)."
+    puts
+    puts "   e.g."
+    puts "      ./script/generate site super_value_cart"
+    puts
+    puts "  Then start the server with something like"
+    puts "     './script/server -s super_value_cart'"
+  end
+  puts "=> Shutting down."
+  exit
+end
+
+require 'webrick_server'
+
+class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
+  def handle_file(req, res)
+    begin
+      req = req.dup
+      path = req.path.dup
+
+      # Add .html if the last path piece has no . in it
+      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
+      path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
+
+      req.instance_variable_set(:@path_info, path) # Set the modified path...
+
+      # Dynamically switch the Servlet's root (public) folder on a per-request
+      # basis depending on whether or not the requested file exists in the
+      # site's public folder or the base public folder.
+      base_public = File.join(ABSOLUTE_RAILS_ROOT, 'public')
+      site_public = File.expand_path(File.join(ABSOLUTE_RAILS_ROOT, SITE_ROOT, 'public'))
+      if File.exist? File.join(site_public, path)
+        # The file was found to exist in the site-specific folder, so go there:
+        root = site_public
+      else
+        # Revert to the application base whether or not the file exists here.
+        # A "file not found" (or 404) message will occur if the file is also not 
+        # found in the RAILS_ROOT/public folder.
+        root = base_public
+      end
+
+      @file_handler.instance_variable_set(:@root, root) # Set the modified root...
+
+      @file_handler.send(:service, req, res)
+      return true
+    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
+      res.set_error(err)
+      return true
+    rescue => err
+      return false
+    end
+  end
+end
+
+OPTIONS['working_directory'] = File.expand_path(RAILS_ROOT)
+
+puts "=> Productized Rails Application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+puts "   Please visit http://inquirylabs.com/productize/ for help related to the"
+puts "   productized version of rails.  [Author: duane.johnson@gmail.com]"
+puts
+puts "=> Operating for the following site: '#{SITE}'"
+puts "=> Ctrl-C to shutdown server; call with --help for options" if OPTIONS[:server_type] == WEBrick::SimpleServer
+DispatchServlet.dispatch(OPTIONS)

data/bin/tracker

@@ -0,0 +1,69 @@
+#!/usr/local/bin/ruby
+
+require 'drb'
+require 'thread'
+
+def message(s)
+  $stderr.puts "tracker: #{s}" if ENV && ENV["DEBUG_GATEWAY"]
+end
+
+class Tracker
+  include DRbUndumped
+
+  def initialize(instances, socket_path)
+    @instances = instances
+    @socket = File.expand_path(socket_path)
+    @active = false
+
+    @listeners = []
+    @instances.times { @listeners << Mutex.new }
+
+    message "using #{@listeners.length} listeners"
+    message "opening socket at #{@socket}"
+
+    @service = DRb.start_service("drbunix://#{@socket}", self)
+  end
+
+  def with_listener
+    message "listener requested"
+
+    mutex = has_lock = index = nil
+    3.times do 
+      @listeners.each_with_index do |mutex, index|
+        has_lock = mutex.try_lock
+        break if has_lock
+      end
+      break if has_lock
+      sleep 0.05
+    end
+
+    if has_lock
+      message "obtained listener #{index}"
+      @active = true
+      begin yield index
+      ensure
+        mutex.unlock
+        message "released listener #{index}"
+      end
+    else
+      message "dropping request because no listeners are available!"
+    end
+  end
+
+  def background(check_interval = nil)
+    if check_interval
+      loop do
+        sleep check_interval
+        message "Idle for #{check_interval}, shutting down" unless @active
+        @active = false
+        Kernel.exit 0
+      end
+    else DRb.thread.join
+    end
+  end
+end
+
+socket_path = ARGV.shift
+instances = ARGV.shift.to_i
+t = Tracker.new(instances, socket_path)
+t.background(ARGV.first ? ARGV.shift.to_i : 90)

data/bin/update

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby
+require File.dirname(__FILE__) + '/../config/environment'
+require 'rails_generator'
+require 'rails_generator/scripts/update'
+Rails::Generator::Scripts::Update.new.run(ARGV)

data/configs/apache/vhost.example.conf

@@ -0,0 +1,42 @@
+# Apache VirtualHost Sample Configuration File
+#
+# == General Apache Setup ==
+#
+# Duplicate this file for each specific site within your productized
+# application.  In your Apache global configuration (e.g. httpd.conf) file,
+# add a line to include all of these conf files
+# (e.g. 'Include /Products/generic_cart/config/apache/*')
+#
+# == What You Need to do to This File ==
+#
+# 1. Replace all occurrences of '/Products/generic_cart' with the absolute
+#    path to your generic application's root.
+#
+# 2. Replace all occurrences of 'client_co' with the instance of the specific
+#    site you want to create.  Note that the site name you choose should
+#    correspond with the database prefix.  For example, if you choose 
+#    "cup_of_tea_cart" then there should be the following databases set up:
+#      * cup_of_tea_test (Test database)
+#      * cup_of_tea_dev (Development database)
+#      * cup_of_tea (Production database)
+#
+# 3. Replace 'www.example.com' with the actual name of your VirtualHost
+#
+
+FastCgiServer /Products/generic_cart/sites/client_co/public/dispatch.fcgi -processes 1 -initial-env SITE=client_co
+
+<Directory "/Products/generic_cart/sites/client_co/public/">
+    AllowOverride All
+</Directory>
+
+# Remember to make sure "NameVirtualHost *:80" is set in Apache's main config file
+# (e.g. httpd.conf) so we can use VirtualHosts.
+<VirtualHost *:80>
+    ServerName www.example.com
+    DocumentRoot /Products/generic_cart/sites/client_co/public/
+
+    # The following alias is important since it will allow this particular site to
+    # seemlessly use the generic app's resources, e.g. images, javascripts etc. without
+    # having to copy all files to the site-specific public/ folder:
+    Alias /generic /Products/generic_cart/public/
+</VirtualHost>