rails-app-installer 0.1.0

data/README

@@ -0,0 +1,32 @@
+This is an installer for Rails applications. It's designed to allow users to
+install Rails apps onto their own systems with a minimum amount of effort.
+
+This installer was originally part of Typo (http://typosphere.org).
+
+Adding the installer to your Rails app
+--------------------------------------
+
+To add the installer to your application, copy the `installer` file from the
+examples directory into your project's `bin` directory, and rename it to match
+your application name. For example, Typo's installer lives in `bin/typo`. Then
+modify your installer as needed, customizing the application name, support
+address, and required Rails version. Once this is complete, create an
+`installer` directory for your app and copy
+`examples/rails_installer_defaults.yml` into it. You can probably use it
+unchanged.
+
+You should now be able to test the installer like this:
+
+    $ ruby ./bin/my_installer install /tmp/foo cwd
+
+This will try to install your app in `/tmp/foo` using the current directory as
+a template.  If you leave off the `cwd` option at the end, then the installer will look for the most recent Ruby GEM for your app, using the `application_name` line from the installer as the gem name.
+
+Creating a Gem
+--------------
+
+
+
+Using the installer
+-------------------
+

data/examples/installer

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rails-installer'
+
+class AppInstaller < RailsInstaller
+  application_name 'my_shiny_metal_app'
+  support_location 'our shiny website'
+  rails_version '1.1.4'
+end
+
+# Installer program
+directory = ARGV[1]
+
+app = AppInstaller.new(directory)
+app.message_proc = Proc.new do |msg|
+  STDERR.puts " #{msg}"
+end
+app.execute_command(*ARGV)

data/examples/rails_installer_defaults.yml

@@ -0,0 +1,5 @@
+--- 
+rails-environment: production
+database: sqlite
+web-server: mongrel
+threads: 2

data/examples/typo

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'rails-installer'
+
+class TypoInstaller < RailsInstaller
+  application_name 'typo'
+  support_location 'the Typo mailing list'
+  rails_version '1.1.4'
+  
+  def install_post_hook
+    sweep_cache
+  end
+  
+  # Sweep the cache
+  def sweep_cache
+    Dir.chdir(install_directory)
+    message "Cleaning out #{@@app_name.capitalize}'s cache"
+    status = system("rake -s sweep_cache > /dev/null 2> /dev/null")
+  end
+end
+
+class SweepCache < RailsInstaller::Command
+  help "Sweep Typo's cache"
+  
+  def self.command(installer, *args)
+    installer.sweep_cache
+  end
+end
+
+# Installer program
+directory = ARGV[1]
+
+typo = TypoInstaller.new(directory)
+typo.message_proc = Proc.new do |msg|
+  STDERR.puts " #{msg}"
+end
+typo.execute_command(*ARGV)

data/lib/apache13.conf.example.template

@@ -0,0 +1,33 @@
+# Apache 1.3 HTTP proxy example for Typo with Mongrel
+#
+# Before any of this will work, you need to make sure that the mod_proxy 
+# modules are loaded.  For shared hosting, your provider will have do this 
+# globally.  The line required looks like this, although the exact path may 
+# vary:
+#
+#   LoadModule proxy_module /usr/lib/apache/modules/mod_proxy.so                   
+#
+# Then you'll want a VirtualHost section that looks about like this:
+
+<VirtualHost blog.example.com>
+  ServerName blog.example.com
+  ServerAlias www.blog.example.com
+
+  # Change this to your email address
+  ServerAdmin webmaster@localhost
+
+  # Change these to be valid paths for your host.  The DocumentRoot path
+  # isn't very important because we don't actually use it for anything.
+  # For security's sake, it's best that it points to an empty directory,
+  # but that's not critical.
+  DocumentRoot /var/www/blog
+  ErrorLog /var/log/apache2/blog_error.log
+  CustomLog /var/log/apache2/blog_access.log combined
+
+  ServerSignature On
+
+  # This is the important part--it sets up proxying.
+  ProxyRequests Off
+  ProxyPass / $RAILS_URL
+  ProxyPassReverse / $RAILS_URL
+</VirtualHost>

data/lib/apache20.conf.example.template

@@ -0,0 +1,40 @@
+# Apache 2.0/2.2 HTTP proxy example for Typo with Mongrel
+#
+# Before any of this will work, you need to make sure that the mod_proxy and 
+# mod_proxy_http modules are loaded.  For shared hosting, your provider will 
+# have do this globally.  The two lines required look like this, although the 
+# exact path may vary:
+#
+#   LoadModule proxy_module /usr/lib/apache2/modules/mod_proxy.so                   
+#   LoadModule proxy_http_module /usr/lib/apache2/modules/mod_proxy_http.so 
+#
+# Then you'll want a VirtualHost section that looks about like this:
+
+<VirtualHost blog.example.com>
+  ServerName blog.example.com
+  ServerAlias www.blog.example.com
+
+  # Change this to your email address
+  ServerAdmin webmaster@localhost
+
+  # Change these to be valid paths for your host.  The DocumentRoot path
+  # isn't very important because we don't actually use it for anything.
+  # For security's sake, it's best that it points to an empty directory,
+  # but that's not critical.
+  DocumentRoot /var/www/blog
+  ErrorLog /var/log/apache2/blog_error.log
+  CustomLog /var/log/apache2/blog_access.log combined
+
+  ServerSignature On
+
+  # This is the important part--it sets up proxying.
+  ProxyRequests Off
+  <Proxy *>
+    Order deny,allow
+    Allow from all
+  </Proxy>
+
+  ProxyPass / $RAILS_URL
+  ProxyPassReverse / $RAILS_URL
+  ProxyPreserveHost On
+</VirtualHost>

data/lib/lighttpd.conf.example.template

@@ -0,0 +1,6 @@
+# This is untested and incomplete.
+# See http://mongrel.rubyforge.org/docs/lighttpd.html
+# 
+proxy.balance = "fair" 
+proxy.server  = ( "/" => 
+     ( ( "host" => "$RAILS_HOST", "port" => $RAILS_PORT ) ) )

data/lib/rails-installer.rb

@@ -0,0 +1,575 @@
+require 'rubygems'
+
+require 'fileutils'
+require 'yaml'
+require 'digest/sha1'
+
+require 'rails-installer/databases'
+require 'rails-installer/web-servers'
+require 'rails-installer/commands'
+
+#
+# An installer for Rails applications.
+#
+# The Rails Application Installer is designed to make it easy for end-users to
+# install open-source Rails apps with a minimum amount of effort.  When built 
+# properly, all the user needs to do is run:
+#
+#    $ gem install my_app
+#    $ my_app install /some/path
+#
+# To use this installer, you'll need to create a small driver program (the
+# 'my_app' program from above).  Here's a minimal example:
+#
+#    #!/usr/bin/env ruby
+#
+#    require 'rubygems'
+#    require 'rails-installer'
+#
+#    class AppInstaller < RailsInstaller
+#      application_name 'my_shiny_metal_app'
+#      support_location 'our shiny website'
+#      rails_version '1.1.4'
+#    end
+#
+#    # Installer program
+#    directory = ARGV[1]
+#
+#    app = AppInstaller.new(directory)
+#    app.message_proc = Proc.new do |msg|
+#      STDERR.puts " #{msg}"
+#    end
+#    app.execute_command(*ARGV)
+#
+# Place this in your application's gem/ directory, and then add it to your
+# .gem using the 'executables' gemspec option. See the examples/ directory for
+# more complex examples.
+class RailsInstaller
+  include FileUtils
+  attr_accessor :install_directory, :source_directory, :config
+  attr_accessor :message_proc
+  
+  class InstallFailed < StandardError; end
+
+  @@rails_version = nil
+  
+  # The application name.  Set this in your derived class.
+  def self.application_name(name)
+    @@app_name = name
+  end
+  
+  # The support location.  This is displayed to the user at the end of the 
+  # install process.
+  def self.support_location(location)
+    @@support_location = location
+  end
+  
+  # Which Rails version this app needs.  This version of Rails will be frozen
+  # into vendor/rails/
+  def self.rails_version(svn_tag)
+    @@rails_version = svn_tag
+  end
+  
+  # The application name, as set by +application_name+.
+  def app_name
+    @@app_name
+  end
+
+  def initialize(install_directory)
+    # use an absolute path, not a relative path.
+    if install_directory
+      @install_directory = File.expand_path(install_directory)
+    end
+        
+    @config = read_yml(config_file) rescue nil
+    @config ||= Hash.new
+  end
+  
+  # Display a status message
+  def message(string)
+    if message_proc
+      message_proc.call(string)
+    else
+      STDERR.puts string
+    end
+  end
+
+  # Install Application
+  def install(version=nil)
+    @source_directory = find_source_directory(@@app_name,version)
+
+    # Merge default configuration settings
+    @config = read_yml(backup_config_file).merge(config)
+    
+    install_sequence
+    
+    message ''
+    message "#{@@app_name.capitalize} is now running on http://#{`hostname`.chomp}:#{config['port-number']}"
+    message "Use '#{@@app_name} start #{install_directory}' to restart after boot."
+    message "Look in installer/*.conf.example to see how to integrate with your web server."
+  end
+  
+  # The default install sequence.  Override this if you need to add extra
+  # steps to the installer.
+  def install_sequence
+    stop
+    
+    backup_database
+    install_pre_hook
+    pre_migrate_database
+    copy_files
+    freeze_rails
+    create_default_config_files
+    fix_permissions
+    create_directories
+    create_initial_database
+    set_initial_port_number
+    expand_template_files
+    
+    migrate
+    install_post_hook
+    save
+    
+    run_rails_tests
+    
+    start
+  end
+  
+  # The easy way to add steps to the installation process.  +install_pre_hook+
+  # runs right after the DB is backed up and right before the first migration
+  # attempt.
+  def install_pre_hook
+  end
+  
+  # Another install hook; +install_post_hook+ runs after the final migration.
+  def install_post_hook
+  end
+  
+  # Start application in the background
+  def start(foreground = false)
+    server_class = RailsInstaller::WebServer.servers[config['web-server']]
+    if not server_class
+      message "** warning: web-server #{config['web-server']} unknown.  Use 'web-server=external' to disable."
+    end
+    
+    server_class.start(self,foreground)
+  end
+  
+  # Stop application
+  def stop
+    return unless File.directory?(install_directory)
+    
+    server_class = RailsInstaller::WebServer.servers[config['web-server']]
+    if not server_class
+      message "** warning: web-server #{config['web-server']} unknown.  Use 'web-server=external' to disable."
+    end
+    
+    server_class.stop(self)
+  end
+  
+  # Backup the database
+  def backup_database
+    db_class = RailsInstaller::Database.dbs[config['database']]
+    db_class.backup(self)
+  end
+  
+  # Restore the database
+  def restore_database(filename)
+    db_class = RailsInstaller::Database.dbs[config['database']]
+    in_directory install_directory do
+      db_class.restore(self, filename)
+    end
+  end
+
+  # Copy files from the source directory to the target directory.
+  def copy_files
+    message "Checking for existing #{@@app_name.capitalize} install in #{install_directory}"
+    files_yml = File.join(install_directory,'installer','files.yml')
+    old_files = read_yml(files_yml) rescue Hash.new
+    
+    message "Reading files from #{source_directory}"
+    new_files = sha1_hash_directory_tree(source_directory)
+    new_files.delete('/config/database.yml') # Never copy this.
+    
+    # Next, we compare the original install hash to the current hash.  For each
+    # entry:
+    #
+    # - in new_file but not in old_files: copy
+    # - in old files but not in new_files: delete
+    # - in both, but hash different: copy
+    # - in both, hash same: don't copy
+    #
+    # We really should add a third hash (existing_files) and compare against that
+    # so we don't overwrite changed files.
+
+    added, changed, deleted, same = hash_diff(old_files, new_files)
+    
+    if added.size > 0
+      message "Copying #{added.size} new files into #{install_directory}"
+      added.keys.sort.each do |file|
+        message " copying #{file}"
+        copy_one_file(file)
+      end
+    end
+    
+    if changed.size > 0
+      message "Updating #{changed.size} files in #{install_directory}"
+      changed.keys.sort.each do |file|
+        message " updating #{file}"
+        copy_one_file(file)
+      end
+    end
+    
+    if deleted.size > 0
+      message "Deleting #{deleted.size} files from #{install_directory}"
+      
+      deleted.keys.sort.each do |file|
+        message " deleting #{file}"
+        rm(File.join(install_directory,file))
+      end
+    end
+    
+    write_yml(files_yml,new_files)
+  end
+
+  # Copy one file from source_directory to install_directory, creating
+  # directories as needed.
+  def copy_one_file(filename)
+    source_name = File.join(source_directory,filename)
+    install_name = File.join(install_directory,filename)
+    dir_name = File.dirname(install_name)
+    
+    mkdir_p(dir_name)
+    cp(source_name,install_name,:preserve => true)
+  end
+  
+  # Compute the different between two hashes.  Returns four hashes,
+  # one contains the keys that are in 'b' but not in 'a' (added entries),
+  # the next contains keys that are in 'a' and 'b', but have different values
+  # (changed).  The third contains keys that are in 'b' but not 'a' (added).
+  # The final hash contains items that are the same in each.
+  def hash_diff(a, b)
+    added = {}
+    changed = {}
+    deleted = {}
+    same = {}
+    
+    seen = {}
+    
+    a.each_key do |k|
+      seen[k] = true
+      
+      if b.has_key? k
+        if b[k] == a[k]
+          same[k] = true
+        else
+          changed[k] = true
+        end
+      else
+        deleted[k] = true
+      end
+    end
+    
+    b.each_key do |k|
+      unless seen[k]
+        added[k] = true
+      end
+    end
+    
+    [added, changed, deleted, same]
+  end
+  
+  # Freeze to a specific version of Rails gems.
+  def freeze_rails
+    return unless @@rails_version
+    version_file = File.join(install_directory,'vendor','rails-version')
+    vendor_rails = File.join(install_directory,'vendor','rails')
+    
+    old_version = File.read(version_file).chomp rescue nil
+    
+    if @@rails_version == old_version
+      return
+    elsif old_version != nil
+      rm_rf(vendor_rails)
+    end
+
+    mkdir_p(vendor_rails)
+    
+    package_map = {
+      'rails' => File.join(vendor_rails,'railties'),
+      'actionmailer' => File.join(vendor_rails,'actionmailer'),
+      'actionpack' => File.join(vendor_rails,'actionpack'),
+      'actionwebservice' => File.join(vendor_rails,'actionwebservice'),
+      'activerecord' => File.join(vendor_rails,'activerecord'),
+      'activesupport' => File.join(vendor_rails,'activesupport'),
+    }
+    
+    specs = Gem.source_index.find_name('rails',["= #{@@rails_version}"])
+    
+    unless specs.to_a.size > 0
+      raise InstallFailed, "Can't locate Rails #{@@rails_version}!"
+    end
+    
+    copy_gem(specs.first, package_map[specs.first.name])
+    
+    specs.first.dependencies.each do |dep|
+      next unless package_map[dep.name]
+      
+      dep_spec = Gem.source_index.find_name(dep.name,[dep.version_requirements.to_s])
+      if dep_spec.size == 0
+        raise InstallFailed, "Can't locate dependency #{dep.name} #{dep.version_requirements.to_s}"
+      end
+      
+      copy_gem(dep_spec.first, package_map[dep.name])
+    end
+    
+    File.open(version_file,'w') do |f|
+      f.puts @@rails_version
+    end
+  end
+  
+  # Copy a specific gem's contents.
+  def copy_gem(spec, destination)
+    message("copying #{spec.name} #{spec.version} to #{destination}")
+    cp_r("#{spec.full_gem_path}/.",destination)
+  end
+  
+  # Create all default config files
+  def create_default_config_files
+    create_default_database_yml
+  end
+  
+  # Create the default database.yml
+  def create_default_database_yml
+    db_class = RailsInstaller::Database.dbs[config['database']]
+    db_class.database_yml(self)
+  end
+  
+  # Clean up file and directory permissions.
+  def fix_permissions
+    unless RUBY_PLATFORM =~ /mswin32/
+      message "Making scripts executable"
+      chmod 0555, File.join(install_directory,'public','dispatch.fcgi')
+      chmod 0555, File.join(install_directory,'public','dispatch.cgi')
+      chmod 0555, Dir[File.join(install_directory,'script','*')]
+    end
+  end
+  
+  # Create required directories, like tmp
+  def create_directories
+    mkdir_p(File.join(install_directory,'tmp','cache'))
+    chmod(0755, File.join(install_directory,'tmp','cache'))
+    mkdir_p(File.join(install_directory,'tmp','session'))
+    mkdir_p(File.join(install_directory,'tmp','sockets'))
+    mkdir_p(File.join(install_directory,'log'))
+    File.open(File.join(install_directory,'log','development.log'),'w')
+    File.open(File.join(install_directory,'log','production.log'),'w')
+    File.open(File.join(install_directory,'log','testing.log'),'w')
+  end
+  
+  # Create the initial SQLite database
+  def create_initial_database
+    db_class = RailsInstaller::Database.dbs[config['database']]
+    in_directory(install_directory) do
+      db_class.create(self)
+    end
+  end
+  
+  # Get the current schema version
+  def get_schema_version
+    File.read(File.join(install_directory,'db','schema_version')).to_i rescue 0
+  end
+  
+  # The path to the installed config file
+  def config_file
+    File.join(install_directory,'installer','rails_installer.yml')
+  end
+
+  # The path to the config file that comes with the GEM
+  def backup_config_file
+    File.join(source_directory,'installer','rails_installer_defaults.yml')
+  end
+  
+  # Pick a default port number
+  def set_initial_port_number
+    config['port-number'] ||= (rand(1000)+4000)
+  end
+  
+  # Pre-migrate the database.  This checks to see if we're downgrading to an
+  # earlier version of our app, and runs 'rake migrate VERSION=...' to
+  # downgrade the database.
+  def pre_migrate_database
+    old_schema_version = get_schema_version
+    new_schema_version = File.read(File.join(source_directory,'db','schema_version')).to_i
+    
+    return unless old_schema_version > 0
+     
+    # Are we downgrading?
+    if old_schema_version > new_schema_version
+      message "Downgrading schema from #{old_schema_version} to #{new_schema_version}"
+      
+      in_directory install_directory do
+        unless system("rake -s migrate VERSION=#{new_schema_version}")
+          raise InstallFailed, "Downgrade migrating from #{old_schema_version} to #{new_schema_version} failed."
+        end
+      end
+    end
+  end
+  
+  # Migrate the database
+  def migrate
+    message "Migrating #{@@app_name.capitalize}'s database to newest release"
+    
+    in_directory install_directory do
+      unless system("rake -s migrate")
+        raise InstallFailed, "Migration failed"
+      end
+    end
+  end
+
+  # Run Rails tests.  This helps verify that we have a clean install
+  # with all dependencies.  This cuts down on a lot of bug reports.
+  def run_rails_tests
+    message "Running tests.  This may take a minute or two"
+    
+    in_directory install_directory do
+      if system_silently("rake -s test")
+        message "All tests pass.  Congratulations."
+      else
+        message "***** Tests failed *****"
+        message "** Please run 'rake test' by hand in your install directory."
+        message "** Report problems to #{@@support_location}."
+        message "***** Tests failed *****"
+      end
+    end
+  end
+
+  # Find all files in a directory tree and return a Hash containing sha1
+  # hashes of all files.
+  def sha1_hash_directory_tree(directory, prefix='', hash={})
+    Dir.entries(directory).each do |file|
+      next if file =~ /^\./
+      pathname = File.join(directory,file)
+      if File.directory?(pathname)
+        sha1_hash_directory_tree(pathname, File.join(prefix,file), hash)
+      else
+        hash[File.join(prefix,file)] = Digest::SHA1.hexdigest(File.read(pathname))
+      end
+    end
+    
+    hash
+  end
+
+  # Save config settings
+  def save
+    write_yml(config_file,@config)
+  end
+  
+  # Load a yaml file
+  def read_yml(filename)
+    YAML.load(File.read(filename))
+  end
+  
+  # Save a yaml file.
+  def write_yml(filename,object)
+    File.open(filename,'w') do |f|
+      f.write(YAML.dump(object))
+    end
+  end
+  
+  # Locate the source directory for a specific Version
+  def find_source_directory(gem_name, version)
+    if version == 'cwd'
+      return Dir.pwd
+    elsif version
+      version_array = ["= #{version}"]
+    else
+      version_array = ["> 0.0.0"]
+    end
+    
+    specs = Gem.source_index.find_name(gem_name,version_array)
+    unless specs.to_a.size > 0
+      raise InstallFailed, "Can't locate version #{version}!"
+    end
+    
+    specs.last.full_gem_path
+  end
+  
+  # Call +system+, ignoring all output.
+  def system_silently(command)
+    if RUBY_PLATFORM =~ /mswin32/
+      null = 'NUL:'
+    else
+      null = '/dev/null'
+    end
+    
+    system("#{command} > #{null} 2> #{null}")
+  end
+  
+  # Expand configuration template files.
+  def expand_template_files
+    rails_host = config['bind-address'] || `hostname`.chomp
+    rails_port = config['port-number'].to_s
+    rails_url = "http://#{rails_host}:#{rails_port}"
+    Dir[File.join(install_directory,'installer','*.template')].each do |template_file|
+      output_file = template_file.gsub(/\.template/,'')
+      next if File.exists?(output_file) # don't overwrite files
+
+      message "expanding #{File.basename(output_file)} template"
+      
+      text = File.read(template_file).gsub(/\$RAILS_URL/,rails_url).gsub(/\$RAILS_HOST/,rails_host).gsub(/\$RAILS_PORT/,rails_port)
+      
+      File.open(output_file,'w') do |f|
+        f.write text
+      end
+    end
+  end
+  
+  # Execute a command-line command
+  def execute_command(*args)
+    if args.size < 2
+      display_help
+      exit(1)
+    end
+    
+    command_class = Command.commands[args.first]
+    
+    if command_class
+      command_class.command(self,*(args[2..-1]))
+    else
+      display_help
+      exit(1)
+    end
+  end
+  
+  # Display help.
+  def display_help(error=nil)
+    STDERR.puts error if error
+    
+    commands = Command.commands.keys.sort
+    commands.each do |cmd|
+      cmd_class = Command.commands[cmd]
+      flag_help = cmd_class.flag_help_text.gsub(/APPNAME/,app_name)
+      help = cmd_class.help_text.gsub(/APPNAME/,app_name)
+      
+      STDERR.puts "  #{app_name} #{cmd} DIRECTORY #{flag_help}"
+      STDERR.puts "    #{help}"
+    end
+  end
+end
+
+# Run a block inside of a specific directory.  Chdir into the directory
+# before executing the block, then chdir back to the original directory
+# when the block exits.
+def in_directory(directory)
+  begin
+    old_dir = Dir.pwd
+    Dir.chdir(directory)
+    value = yield
+  ensure
+    Dir.chdir(old_dir)
+  end
+  
+  return value
+end
+

data/lib/rails-installer/commands.rb

@@ -0,0 +1,187 @@
+class RailsInstaller
+  
+  # Parent class for command-line subcommand plugins for the installer.  Each
+  # subclass must implement the +command+ class method and should provide help
+  # text using the +help+ method.  Example (from Typo):
+  #
+  #   class SweepCache < RailsInstaller::Command
+  #     help "Sweep Typo's cache"
+  #
+  #     def self.command(installer, *args)
+  #      installer.sweep_cache
+  #     end
+  #   end
+  #
+  # This implements a +sweep_cache+ command that Typo users can access by
+  # running 'typo sweep_cache /some/path'.
+  #
+  # Subcommands that need arguments should use both 'help' and 'flag_help',
+  # and then use the +args+ parameter to find their arguments.  For example,
+  # the +install+ subcommand looks like this:
+  #
+  #   class Install < RailsInstaller::Command
+  #     help "Install or upgrade APPNAME in PATH."
+  #     flag_help "[VERSION] [KEY=VALUE]..."
+  #
+  #     def self.command(installer, *args)
+  #       version = nil
+  #       args.each do |arg|
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  class Command
+    @@command_map = {}
+    
+    # The +command+ method implements this sub-command.  It's called by the
+    # command-line parser when the user asks for this sub-command.
+    def self.command(installer, *args)
+      raise "Not Implemented"
+    end
+    
+    # +flag_help+ sets the help text for any arguments that this sub-command
+    # accepts.  It defaults to ''.
+    def self.flag_help(text)
+      @flag_help = text
+    end
+    
+    # Return the flag help text.
+    def self.flag_help_text
+      @flag_help || ''
+    end
+    
+    # +help+ sets the help text for this subcommand.
+    def self.help(text)
+      @help = text
+    end
+    
+    # Return the help text.
+    def self.help_text
+      @help || ''
+    end
+  
+    def self.inherited(sub)
+      name = sub.to_s.gsub(/^.*::/,'').gsub(/([A-Z])/) do |match|
+        "_#{match.downcase}"
+      end.gsub(/^_/,'')
+
+      @@command_map[name] = sub
+    end
+    
+    def self.commands
+      @@command_map
+    end
+    
+    # The +install+ command installs the application into a specific path.
+    # Optionally, the user can request a specific version to install.  If
+    # the version string is 'cwd', then the current directory is used as a
+    # template; otherwise it looks for the specified version number in the
+    # local Gems repository.
+    class Install < RailsInstaller::Command
+      help "Install or upgrade APPNAME in PATH."
+      flag_help "[VERSION] [KEY=VALUE]..."
+
+      def self.command(installer, *args)
+        version = nil
+        args.each do |arg|
+          if(arg =~ /^([^=]+)=(.*)$/)
+            installer.config[$1.to_s] = $2.to_s
+          else
+            version = arg
+          end
+        end
+        
+        installer.install(version)
+      end
+    end
+    
+    # The +config+ command controls the installation's config
+    # parameters.  Running 'installer config /some/path' will show
+    # all of the config parameters for the installation in /some/path.
+    # You can set params with 'key=value', or clear them with 'key='.
+    class Config < RailsInstaller::Command
+      help "Read or set a configuration variable"
+      flag_help '[KEY=VALUE]...'
+
+      def self.command(installer, *args)
+        if args.size == 0
+          installer.config.keys.sort.each do |k|
+            puts "#{k}=#{installer.config[k]}"
+          end
+        else
+          args.each do |arg|
+            if(arg=~/^([^=]+)=(.*)$/)
+              if $2.to_s.empty?
+                installer.config.delete($1.to_s)
+              else
+                installer.config[$1.to_s]=$2.to_s
+              end
+            else
+              puts installer.config[arg]
+            end
+          end
+          installer.save
+        end
+      end
+    end
+    
+    # The +start+ command starts a web server in the background for the
+    # specified installation, if applicable.
+    class Start < RailsInstaller::Command
+      help "Start the web server in the background"
+
+      def self.command(installer, *args)
+        installer.start
+      end
+    end
+
+    # The +run+ command starts a web server in the foreground.
+    class Run < RailsInstaller::Command
+      help "Start the web server in the foreground"
+      
+      def self.command(installer, *args)
+        installer.start(true)
+      end
+    end
+
+    # The +restart+ command stops and restarts the web server.
+    class Restart < RailsInstaller::Command
+      help "Stop and restart the web server."
+      
+      def self.command(installer, *args)
+        installer.stop
+        installer.start
+      end
+    end
+    
+    # The +stop+ command shuts down the web server.
+    class Stop < RailsInstaller::Command
+      help "Stop the web server"
+      
+      def self.command(installer, *args)
+        installer.stop
+      end
+    end
+    
+    # The +backup+ command backs the database up into 'db/backups'.
+    class Backup < RailsInstaller::Command
+      help "Back up the database"
+      
+      def self.command(installer, *args)
+        installer.backup_database
+      end
+    end
+    
+    # The +restore+ command restores a backup.
+    class Restore < RailsInstaller::Command
+      help "Restore a database backup"
+      flag_help 'BACKUP_FILENAME'
+      
+      def self.command(installer, *args)
+        installer.restore_database(args.first)
+      end
+    end
+  end
+end
+  

data/lib/rails-installer/databases.rb

@@ -0,0 +1,222 @@
+require 'active_record'
+
+class RailsInstaller
+  
+  # Parent class for database plugins for the installer.  To create a new 
+  # database handler, subclass this class and define a +yml+ class and
+  # optionally a +create_database+ method.
+  class Database
+    @@db_map = {}
+
+    # Connect to the database (using the 'database.yml' generated by the +yml+
+    # method).  Returns true if the database already exists, and false if the
+    # database doesn't exist yet.
+    def self.connect(installer)
+      ActiveRecord::Base.establish_connection( 
+        YAML.load(yml(installer))['production'])
+      begin
+        tables = ActiveRecord::Base.connection.tables
+        if tables.size > 0
+          return true
+        end
+      rescue
+        # okay
+      end
+      return false
+    end
+    
+    # Back up the database.  This is fully DB and schema agnostic.  It
+    # serializes all tables to a single YAML file.
+    def self.backup(installer)
+      STDERR.puts "** backup **"
+      return unless connect(installer)
+      
+      interesting_tables = ActiveRecord::Base.connection.tables.sort - ['sessions']
+      backup_dir = File.join(installer.install_directory, 'db', 'backup')
+      FileUtils.mkdir_p backup_dir
+      backup_file = File.join(backup_dir, "backup-#{Time.now.strftime('%Y%m%d-%H%M')}.yml")
+
+      installer.message "Backing up to #{backup_file}"
+      
+      data = {}
+      interesting_tables.each do |tbl|
+        data[tbl] = ActiveRecord::Base.connection.select_all("select * from #{tbl}")
+      end
+
+      File.open(backup_file,'w') do |file|
+        YAML.dump data, file
+      end
+    end
+    
+    # Restore a backup created by +backup+.  Deletes all data before 
+    # importing.
+    def self.restore(installer, filename)
+      connect(installer)
+      data = YAML.load(File.read(filename))
+      
+      installer.message "Restoring data"
+      data.each_key do |table|
+        if table == 'schema_info'
+          ActiveRecord::Base.connection.execute("delete from schema_info")
+          ActiveRecord::Base.connection.execute("insert into schema_info (version) values (#{data[table].first['version']})")
+        else
+          installer.message " Restoring table #{table} (#{data[table].size})"
+
+          # Create a temporary model to talk to the DB
+          eval %Q{
+          class TempClass < ActiveRecord::Base
+            set_table_name '#{table}'
+            reset_column_information
+          end
+          }
+          
+          TempClass.delete_all
+                
+          data[table].each do |record|
+            r = TempClass.new(record)
+            r.save
+          end
+          
+          if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
+            ActiveRecord::Base.connection.reset_pk_sequence!(table)
+          end
+        end
+      end
+    end
+  
+    # Create a 'database.yml' file, using the data from +yml+.
+    def self.database_yml(installer)
+      yml_file = File.join(installer.install_directory,'config','database.yml')
+      return if File.exists? yml_file
+      
+      File.open(yml_file,'w') do |f|
+        f.write(yml(installer))
+      end
+    end
+    
+    # Create the database, including schema creation.  This should be generic
+    # enough that database-specific drivers don't need to override it.
+    #
+    # It calls +create_database+ to actually build a new DB from scratch if
+    # needed.
+    def self.create(installer)
+      installer.message "Checking database"
+      if connect(installer)
+        installer.message "Database exists, preparing for upgrade"
+        return
+      end
+
+      installer.message "Creating initial database"
+      
+      create_database(installer)
+      
+      schema_file = File.join(installer.install_directory,'db',"schema.#{installer.config['database']}.sql")
+      schema = File.read(schema_file)
+      
+      # Remove comments and extra blank lines
+      schema = schema.split(/\n/).map{|l| l.gsub(/^--.*/,'')}.select{|l| !(l=~/^$/)}.join("\n")
+      
+      schema.split(/;\n/).each do |command|
+        ActiveRecord::Base.connection.execute(command)
+      end
+    end
+    
+    # Create a new database from scratch.  Some DBs, like SQLite, don't need
+    # this.  Others will need to override this and call the DB's "create new 
+    # database" command.
+    def self.create_database(installer)
+      # nothing
+    end
+
+    def self.inherited(sub)
+      name = sub.to_s.gsub(/^.*::/,'').gsub(/([A-Z])/) do |match|
+        "_#{match.downcase}"
+      end.gsub(/^_/,'')
+
+      @@db_map[name] = sub
+    end
+    
+    def self.dbs
+      @@db_map
+    end
+  
+    # The driver for SQLite 3.  This is pretty minimal, as all we need is a
+    # +yml+ class to provide a basic 'database.yml'.
+    class Sqlite < RailsInstaller::Database
+      # The name of the sqlite database file
+      def self.db_file(installer)
+        File.join(installer.install_directory,'db','database.sqlite')
+      end
+      
+      def self.yml(installer)
+        %q{
+        login: &login
+          adapter: sqlite3
+          database: db/database.sqlite
+
+        development:
+          <<: *login
+
+        production:
+          <<: *login
+
+        test:
+          database: ":memory:"
+          <<: *login
+        }        
+      end
+    end
+    
+    # A PostgreSQL driver.  This is a bit more work then the SQLite driver, as
+    # Postgres needs to talk to its server.  So it takes a number of config
+    # variables:
+    #
+    #  * db_host
+    #  * db_name
+    #  * db_user
+    #  * db_password
+    #
+    # It will call +createdb+ to set up the db all on its own.
+    class Postgresql < RailsInstaller::Database
+      def self.db_host(installer)
+        installer.config['db_host'] || 'localhost'
+      end
+      
+      def self.db_user(installer)
+        installer.config['db_user'] || ENV['USER'] || installer.app_name 
+      end
+      
+      def self.db_name(installer)
+        installer.config['db_name'] || installer.app_name
+      end
+      
+      def self.yml(installer)
+        %Q{
+        login: &login
+          adapter: postgresql
+          host: #{db_host installer}
+          username: #{db_user installer}
+          password: #{installer.config['db_password']}
+          database: #{db_name installer}
+
+        development:
+          <<: *login
+
+        production:
+          <<: *login
+
+        test:
+          database: #{db_name installer}-test
+          <<: *login
+        }        
+      end
+      
+      # Create a PostgreSQL database.
+      def self.create_database(installer)
+        installer.message "Creating PostgreSQL database"
+        system("createdb -U #{db_user installer} #{db_name installer}")
+        system("createdb -U #{db_user installer} #{db_name installer}-test")
+      end
+    end
+  end
+end

data/lib/rails-installer/web-servers.rb

@@ -0,0 +1,115 @@
+class RailsInstaller
+  
+  # Parent class for webserver plugins for the installer.  To create a new 
+  # webserver handler, subclass this class and define a 'start' and 'stop'
+  # class method.
+  class WebServer
+    @@server_map = {}
+
+    # Start the server
+    def self.start(installer, foreground)
+      raise "Not Implemented"
+    end
+  
+    # Stop the server
+    def self.stop(installer, foreground)
+      raise "Not Implemented"
+    end
+
+    def self.inherited(sub)
+      name = sub.to_s.gsub(/^.*::/,'').gsub(/([A-Z])/) do |match|
+        "_#{match.downcase}"
+      end.gsub(/^_/,'')
+
+      @@server_map[name] = sub
+    end
+    
+    def self.servers
+      @@server_map
+    end
+
+    # A web server plugin for Mongrel (http://mongrel.rubyforge.org).
+    class Mongrel < RailsInstaller::WebServer
+      def self.start(installer, foreground)
+        args = {}
+        args['-p'] = installer.config['port-number']
+        args['-a'] = installer.config['bind-address']
+        args['-e'] = installer.config['rails-environment']
+        args['-d'] = foreground
+        args['-P'] = pid_file(installer)
+        args['--prefix'] = installer.config['url-prefix']
+
+        # Remove keys with nil values
+        args.delete_if {|k,v| v==nil}
+
+        args_array = args.to_a.flatten.map {|e| e.to_s}
+        args_array = ['mongrel_rails', 'start', installer.install_directory] + args_array
+        installer.message "Starting #{installer.app_name.capitalize} on port #{installer.config['port-number']}"
+        in_directory installer.install_directory do
+          system(args_array.join(' '))
+        end
+      end
+  
+      def self.stop(installer)
+        args = {}
+        args['-P'] = pid_file(installer)
+
+        args_array = args.to_a.flatten.map {|e| e.to_s}
+        args_array = ['mongrel_rails', 'stop', installer.install_directory] + args_array
+        installer.message "Stopping #{installer.app_name.capitalize}"
+        in_directory installer.install_directory do
+          system(args_array.join(' '))
+        end
+        
+      end
+      
+      def self.pid_file(installer)
+        File.join(installer.install_directory,'tmp','pid.txt')
+      end
+    end
+    
+    # A web server driver for MongrelCluster.
+    class MongrelCluster < RailsInstaller::WebServer
+      def self.start(installer, foreground)
+        args = {}
+        args['-p'] = installer.config['port-number']
+        args['-a'] = installer.config['bind-address']
+        args['-e'] = installer.config['rails-environment']
+        args['-N'] = installer.config['threads']
+        args['--prefix'] = installer.config['url-prefix']
+
+        # Remove keys with nil values
+        args.delete_if {|k,v| v==nil}
+
+        args_array = args.to_a.flatten.map {|e| e.to_s}
+        args_array = ['mongrel_rails', 'cluster::configure'] + args_array
+        installer.message "Configuring mongrel_cluster for #{installer.app_name.capitalize}"
+        in_directory installer.install_directory do
+          system(args_array.join(' '))
+        end
+        installer.message "Starting #{installer.app_name.capitalize} on port #{installer.config['port-number']}"
+        in_directory installer.install_directory do
+          system('mongrel_rails cluster::start')
+        end
+        
+      end
+  
+      def self.stop(installer)
+        installer.message "Stopping #{installer.app_name.capitalize}"
+        in_directory installer.install_directory do
+          system('mongrel_rails cluster::stop')
+        end
+      end
+    end
+
+    # Do-nothing webserver class.  Used when the installer doesn't control the
+    # web server, like FastCGI.
+    class External < RailsInstaller::WebServer
+      def self.start(installer, foreground)
+      end
+      
+      def self.stop(installer)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: rails-app-installer
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-07-28
+summary: An installer for Rails apps
+require_paths: 
+  - lib
+email: scott@sigkill.org
+homepage: http://scottstuff.net
+rubyforge_project: 
+description: ''
+autorequire: rails-installer
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Scott Laird
+files: 
+  - lib/apache13.conf.example.template
+  - lib/apache20.conf.example.template
+  - lib/lighttpd.conf.example.template
+  - lib/rails-installer
+  - lib/rails-installer.rb
+  - examples/installer
+  - examples/rails_installer_defaults.yml
+  - examples/typo
+  - README
+  - lib/rails-installer/commands.rb
+  - lib/rails-installer/databases.rb
+  - lib/rails-installer/web-servers.rb
+test_files: []
+rdoc_options: 
+  - "--main"
+  - RailsInstaller
+extra_rdoc_files: 
+  - README
+  - lib/rails-installer/commands.rb
+  - lib/rails-installer/databases.rb
+  - lib/rails-installer/web-servers.rb
+executables: []
+extensions: []
+requirements: []
+dependencies: []