skippy-ec2onrails 0.9.10

data/server/files/usr/local/ec2onrails/bin/exec_runner

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    This script allows you to ONLY execute within a shell IF the role of
+#    the server (as defined by capistrano) matches the role specified.
+#    ex.
+#      * exec_runner -role :db -exec 'echo "hello world"'
+#        # will only run if the server is in the db role
+#      * exec_runner -role :app -exec /some/app/specific/script/to/call
+#
+
+require "rubygems"
+require "optiflag"
+
+require "fileutils"
+require "#{File.dirname(__FILE__)}/../lib/roles_helper"
+require "#{File.dirname(__FILE__)}/../lib/utils"
+
+include Ec2onrails::RolesHelper
+
+module CommandLineArgs extend OptiFlagSet
+  optional_flag "role" do
+    description "The role of this server, as defined by capistrano. ex. 'db', or 'app'  If not used, will be applied to all roles"
+  end
+  
+  optional_flag "only_env" do
+    description "Only apply the script if it is running within this environment"
+  end
+
+  flag "exec" do
+    description "what to run if the role of the server matches the -role passed in"
+  end  
+  
+  and_process!
+end
+
+#strip out the ':', in case the user enters ':db', or ':app'
+role = ARGV.flags.role.sub(/^:/, '').to_sym
+if ARGV.flags.role && !in_role?(role)
+  puts "This script is not being run because the server is not running under the #{role} role"
+  exit
+end
+
+curr_env = Ec2onrails::Utils.rails_env
+if ARGV.flags.only_env && ARGV.flags.only_env.strip != curr_env
+  puts "This script is not being run because the server is not running under the #{curr_env} environment"
+  exit
+end
+
+
+# set the default to the current directory; makes it easier to 
+Dir.chdir('/mnt/app/current')
+
+ENV['RAILS_ENV'] = curr_env
+run ARGV.flags.exec
+

data/server/files/usr/local/ec2onrails/bin/init_services.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "#{File.dirname(__FILE__)}/../lib/roles_helper"
+include Ec2onrails::RolesHelper
+
+
+#TODO:
+# if not in a role, we want to make sure that the service is stopped....
+# it gets a little tricky with the web_proxy, which is not enabled if it is
+# not already in a web role. Leave as is, as all it does is throw an error
+# until GOD is in the picture, at which case it should be easy to enable
+# and let it handle it instead of the init.d script....
+
+# memcache role:
+if in_role?(:memcache)
+  # increase memory size, etc if no other roles exist?
+  start(:memcache, "memcached")
+else
+  stop(:memcache, "memcached")
+end
+
+# db primary role:
+if in_role?(:db_primary)
+  start(:db, "mysql", "mysqld")
+else
+  stop(:db, "mysql", "mysqld")
+end
+
+# web role:
+if in_role?(:web)
+  #we symlink the web_proxy we are using....
+  start(:web, "web_proxy", 'nginx apache')
+  # sleep(5)
+  # run("/etc/init.d/web_proxy reload")
+else
+  #not started...
+  stop(:web, "web_proxy", 'nginx apache')
+end
+
+
+# app role:
+if in_role?(:app)
+  start(:app, "mongrel", "mongrel_rails")
+else
+  stop(:app, "mongrel", "mongrel_rails")
+end

data/server/files/usr/local/ec2onrails/bin/optimize_mysql.rb

@@ -0,0 +1,348 @@
+#!/usr/bin/ruby
+
+
+## Notes about optimizations are inline below.
+#  based upon recommendations listed here:
+#  http://www.mysqlperformanceblog.com/2006/09/29/what-to-tune-in-mysql-server-after-installation/
+#
+#  For best effect, call this script after every other service has been started.
+#
+
+require 'fileutils'
+require "/usr/local/ec2onrails/lib/roles_helper"
+require "/usr/local/ec2onrails/lib/vendor/ini"
+require "/usr/local/ec2onrails/lib/mysql_helper"
+require "/usr/local/ec2onrails/lib/utils"
+
+include Ec2onrails::RolesHelper
+
+DEFAULT_CONFIG_LOC = "/etc/mysql/my.cnf"
+
+exit unless in_role?(:db_primary)
+
+local_roles = roles.collect{|r| r.first if r.last.include?('127.0.0.1')}.compact
+only_db_role = local_roles.size < 2
+
+
+#lets make a copy of the original...but do not overwrite if it already exists!
+FileUtils.copy(DEFAULT_CONFIG_LOC, "#{DEFAULT_CONFIG_LOC}.pre_optimized") unless File.exists?("#{DEFAULT_CONFIG_LOC}.pre_optimized")
+
+
+##### ************************** COMPUTE METRICS ************************** #####
+#  define metrics used to modify my.cnf.  These metrics are used as guidelines
+#  and are not meant to be exact measurements or limits.
+#
+#    * how much free memory is available?
+#
+#    * how many other roles is the db server taking on?  Based upon the type
+#      and number of other roles, change the amout of memory we should dedicate
+#      to the db.  This ratio is not the absolute ratio but is used as a guideline
+# 
+#    * how many cores does the slice have.  Then, based upon the Engineyard
+#      recommendation that upto 4 mongrels generally take up one core, compute
+#      the number of estimated available cores
+#
+#    * how many max connections are allowed, and how many database tables exist
+##### ************************ END COMPUTE METRICS ************************ #####
+
+#default is one core
+num_cores = `cat /proc/cpuinfo`.find_all{|o| o =~ /^\s*processor\s+/}.size rescue 1
+#if also running app, just search for ruby because that will 
+#include mongrel but also daemons and other scripts
+num_ruby_instances = local_roles.include?(:app) ? `ps ax | grep ruby | grep -v 'grep ruby'`.split("\n").size : 0
+avail_cores = num_cores - num_ruby_instances/4
+avail_cores = 0 if avail_cores.nil? || avail_cores < 0
+
+
+mem_opt = nil
+mem_opt ||= 0.15 if local_roles.include?(:app) && local_roles.include?(:web) && local_roles.include?(:memcache)
+mem_opt ||= 0.25 if local_roles.include?(:app) && local_roles.include?(:memcache)
+mem_opt ||= 0.35 if local_roles.include?(:app) || local_roles.include?(:memcache)
+mem_opt ||= 0.50 if local_roles.include?(:web)
+mem_opt ||= 0.70  #if only db, lets use a 70% ratio
+
+orig_free_mem  = (`free -m` =~ /buffers\/cache:\s+\d+\s+(\d+)/; $1).to_i rescue 1024 
+
+#TODO: take into account memcached settings if memcached is running on this server
+ruby_mem_reserved = num_ruby_instances * 180
+if orig_free_mem > 4098 && (orig_free_mem * mem_opt + ruby_mem_reserved) * 1.25 < orig_free_mem
+  mem_opt *= 1.5
+end
+free_mem = (orig_free_mem * mem_opt).to_i
+
+@mysql = Ec2onrails::MysqlHelper.new
+         
+# result = sudo("god start db")
+  result = sudo("/etc/init.d/mysql start")
+  if result
+    puts <<-MSG
+****** WOOPS ******
+mysql was not successfully started up.  
+Not optimizing mysql config file
+MSG
+  exit 1
+  end
+  # sleep(10) #make sure the db has some time to start up!
+
+num_connections = 100
+mysql_cmd = %{mysql -u #{@mysql.user} -e "select @@max_connections;"}
+mysql_cmd += " -p'#{@mysql.password}' " unless @mysql.password.nil?
+if `#{mysql_cmd}` =~ /(\d+)/imx
+  num_connections = $1.to_i
+end
+
+num_tables = 100
+mysql_cmd = %{mysql -u #{@mysql.user} -e "SELECT count(*) TABLES from information_schema.tables where TABLE_SCHEMA = '#{@mysql.database}';"}
+mysql_cmd += " -p'#{@mysql.password}' " unless @mysql.password.nil?
+if `#{mysql_cmd}` =~ /(\d+)/imx
+  num_tables = $1.to_i
+end
+
+# the default my.cnf is already different than the default example files... it has already
+# been modified for ec2.  So lets use that one rather than starting from scratch again.
+# default_mysql_config = if free_mem > 2048
+#                          "my-huge.cnf" 
+#                        elsif free_mem > 768
+#                          "my-large.cnf"
+#                        else
+#                          "my-medium.cnf"
+#                        end
+
+puts <<-MSG
+
+Optimizing mysql based off of these stats:
+  * sharing server with these roles : #{local_roles.inspect}
+  * num cores (est avail cores)     : #{num_cores} (#{avail_cores})
+  * avail mem (mem for db)          : #{orig_free_mem} (#{free_mem})
+  * num database tables             : #{num_tables}
+  * max num conns                   : #{num_connections}
+MSG
+
+
+#lets figure out which default config file to start with:
+# new_config = "/etc/mysql/#{default_mysql_config}"
+
+
+##### ******************** Modifying MYSQL config file ******************** #####
+configs = Ini.load(DEFAULT_CONFIG_LOC, :comment => '#')
+configs['mysqld']['key_buffer_size'] ||= configs['mysqld']['key_buffer']
+
+modifying_keys = %w(thread_concurrency thread_cache_size query_cache_size table_cache 
+                    key_buffer_size innodb_flush_log_at_trx_commit 
+                    innodb_buffer_pool_size innodb_additional_mem_pool_size 
+                    innodb_log_buffer_size innodb_log_file_size)
+
+original_values = modifying_keys.inject([]){|all, key| all << [key, configs['mysqld'][key.to_s]]}
+
+
+##### thread_concurrency: only turn on thread concurrency if 
+#     there are some spare 'cores' available
+if avail_cores < 2
+  configs['mysqld'].delete('thread_concurrency')
+elsif
+  # Try number of CPU's*2 for thread_concurrency
+  configs['mysqld']['thread_concurrency'] = (avail_cores) * 2
+end
+
+
+#### thread_cache: we don't want threads being created on a regular basis, but 
+#    if we don't have available cores it doesn't make much sense to cache
+#    to many threads
+configs['mysqld']['thread_cache_size'] = if avail_cores > 6
+                                           24
+                                         elsif avail_cores > 3
+                                           16
+                                         else
+                                           8
+                                         end
+
+
+#### query_cache_size: Important for read-heavy db loads, but it gets expensive
+#    to maintain if it gets too large.
+configs['mysqld']['query_cache_size'] = if free_mem > 4096
+                                          only_db_role ? 512 : 384
+                                        elsif free_mem > 2048
+                                          only_db_role ? 256 : 128
+                                        elsif free_mem > 1024
+                                          only_db_role ? 128 : 64
+                                        else
+                                          64
+                                        end
+configs['mysqld']['query_cache_size'] = "#{configs['mysqld']['query_cache_size']}M"
+
+
+#### table_cache: Opening tables can be expensive, so this cache helps mitigate that.  
+# Each connection needs its own entry in the table cache, but this is less important for innodb 
+# heavy database (which most rails apps are).
+# based upont he observation that a cache size of 1024 is a good size for a db with a few hundred tables
+configs['mysqld']['table_cache'] = (num_connections * num_tables)/10
+
+
+#### key_buffer_size: Does not need to be very large because most rails 
+#    applications do not use MyISAM, or use if very little (usually to store
+#    db-based sessions).  Keep space available for temp tables and other
+#    little mysql needs
+configs['mysqld']['key_buffer_size'] = if free_mem > 4096
+                                    only_db_role ? 256 : 128
+                                  elsif free_mem > 2048
+                                    only_db_role ? 128 : 64
+                                  elsif free_mem > 1024
+                                    only_db_role ? 64 : 32
+                                  else
+                                    16
+                                  end
+configs['mysqld']['key_buffer_size'] = "#{configs['mysqld']['key_buffer_size']}M"
+#can use either key_buffer or key_buffer_size.  
+#Since we are using key_buffer_size, lets remove the other one
+configs['mysqld'].delete('key_buffer') 
+
+
+#### innodb_flush_log_at_trx_commit: this makes INNODB *much* faster, but
+#    it is not 100% ACID compliant.  Instead of flushing to disk for every
+#    commit, this flushes to the OS file cache.  That means that if MySQL
+#    crashes, the data will be written, but if the OS crashes, 1-2
+#    seconds of information could be lost
+configs['mysqld']['innodb_flush_log_at_trx_commit'] = 2
+
+
+# * innodb_buffer_pool_size upto 70% of memory..but if sharing and small data sizes, use less (50%?)
+
+#### innodb_buffer_pool_size: this is where we should put most of our free memory, since
+#    rails apps are heavy users of innodb.  Need to be careful NOT to specify TOO much memory
+configs['mysqld']['innodb_buffer_pool_size'] = if free_mem > 4096
+                                                 free_mem - 512
+                                               elsif free_mem > 2048
+                                                 free_mem - 384
+                                               elsif free_mem > 1024
+                                                 free_mem - 256
+                                               elsif free_mem > 512
+                                                 free_mem - 192
+                                               elsif free_mem > 256
+                                                 free_mem  - 128
+                                               else
+                                                 free_mem - 98
+                                               end
+configs['mysqld']['innodb_buffer_pool_size'] = "#{configs['mysqld']['innodb_buffer_pool_size']}M"
+
+
+#### innodb_additional_mem_pool_size: This is not really needed as most OS's do a good job
+#    of allocating memory.
+configs['mysqld']['innodb_additional_mem_pool_size'] ||= '16M'
+
+
+#### innodb_log_buffer_size: This is flushed every second anyway, so 8-16M is generally ok
+configs['mysqld']['innodb_log_buffer_size'] ||= '12M'
+
+
+#### innodb_log_file_size: Help with heavy writes, 
+#    BUT if it is too large recovery times can be a lot longer
+configs['mysqld']['innodb_log_file_size'] = if free_mem > 4096
+                                              512
+                                            elsif free_mem > 2048
+                                              256
+                                            elsif free_mem > 1024
+                                              128
+                                            else
+                                              64
+                                            end
+configs['mysqld']['innodb_log_file_size'] = "#{configs['mysqld']['innodb_log_file_size']}M"
+##### ****************** END Modifying MYSQL config file ****************** #####
+
+
+
+new_values = modifying_keys.inject([]){|all, key| all << [key, configs['mysqld'][key.to_s]]}
+msg = "\nModified these mysqld parameters:\n"
+msg += <<-MSG
+  mysqld key: new value (original value)   
+-----------------------------------------------  
+MSG
+new_values.each_with_index do |v, i|
+  orig_value = original_values[i].last.nil? ? 'not set' : original_values[i].last
+  msg += <<-MSG
+  * #{v.first}: #{v.last} (#{orig_value})
+  MSG
+end
+puts msg
+
+config_file_loc = DEFAULT_CONFIG_LOC
+#We need to shut down mysql BEFORE we move the new configs over...
+puts "\nCleanly stopping mysql to replace its config file."
+
+#make sure the mysql has time to startup before we shut it down again
+#TODO: can we improve this?
+sleep(5) 
+
+# result = sudo("god stop db")
+# not using god because it doesn't wait for the script to finish
+# before returning....
+# result = sudo("god stop db")
+result = sudo("/etc/init.d/mysql stop")
+clean_stop = true
+if result 
+  config_file_loc += ".optimized"
+  clean_stop = false
+  puts <<-MSG
+****** WOOPS ******
+mysql was not successfully shut down, so we dare not
+update the config file (it can cause problems with the 
+ib_logfile cache).  We have saved the new config file at
+   #{config_file_loc}
+in case you still want to use it in place of
+   #{DEFAULT_CONFIG_LOC}
+MSG
+else
+puts <<-MSG
+cleanly shutdown mysql.  Replacing config file:
+   #{config_file_loc}
+The original config file can be found here:
+   #{DEFAULT_CONFIG_LOC}.pre_optimized
+
+Starting mysql...
+MSG
+end
+
+configs.save(config_file_loc)
+
+config_file = File.read(DEFAULT_CONFIG_LOC)
+File.open(DEFAULT_CONFIG_LOC, 'w') do |file|
+  file << <<-MSG
+# This file is generated by '#{__FILE__}'
+# Based upon the default '#{DEFAULT_CONFIG_LOC}'
+# which is now saved at '#{DEFAULT_CONFIG_LOC}.pre_optimized'
+    
+# See file for comments:
+# #{__FILE__}
+#
+#
+
+MSG
+  file << config_file
+end
+
+if clean_stop  
+  #before we can start, we need to move the old cache files...
+  old_logs = []
+  Dir.glob("/mnt/mysql_data/ib_logfile*").each do |f|
+    FileUtils.mv(f, f + "_old")
+    old_logs << "#{f}_old"
+  end
+  puts <<-MSG
+Moving the old mysql ib logfiles because we might have changed the
+default logfile cache size.  If mysql startups up successfully,
+these files can be removed:
+  #{old_logs.join("\n  ")}
+MSG
+
+
+  # result = sudo("god start db")
+  #using init.d instead of god, because god doesn't wait for the command to finish...
+  #it fires it off and then checks it in x seconds 
+  result = sudo("/etc/init.d/mysql start")
+  if result 
+    puts <<-MSG
+****** WOOPS ******
+mysql was not successfully started up.  
+Check syslog, as the culprit will be logged there.
+MSG
+  end
+end

data/server/files/usr/local/ec2onrails/bin/rails_env

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# This script runs a command with RAILS_ENV set to the value that's specified
+# in the the mongrel_cluster config file. If a command isn't given as an 
+# argument it simply prints the value of RAILS_ENV
+
+require "yaml"
+
+@rails_env = YAML::load_file("/etc/mongrel_cluster/app.yml")["environment"]
+
+if ARGV.any?
+  result = system "env RAILS_ENV=#{@rails_env} #{ARGV.join(' ')}"
+  raise("error: #{$?}") unless result
+else
+  puts @rails_env
+end

data/server/files/usr/local/ec2onrails/bin/rebundle.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+cleanup() {
+  rm -f /ec2onrails-first-boot	
+}
+
+fail() {
+  echo "`basename $0`: ERROR: $1"
+  cleanup
+  exit 1
+}
+
+if [ `whoami` != 'root' ] ; then
+  fail "This script must be run as root, use 'sudo $0'".
+fi
+
+. "/usr/local/ec2onrails/config"
+
+TIMESTAMP="`date '+%Y-%m-%d--%H-%M-%S'`"
+NEW_BUCKET_NAME="$BUCKET_BASE_NAME-image-$TIMESTAMP"
+
+if [ ! -e /usr/local/ec2-api-tools ] ; then
+  echo "The EC2 api command-line tools don't seem to be installed."
+  echo "To install them (and Java, which they require), press enter..."
+  read
+  curl http://s3.amazonaws.com/ec2-downloads/ec2-api-tools.zip > /tmp/ec2-api-tools.zip || fail "couldn't download ec2-api-tools.zip"
+  unzip /tmp/ec2-api-tools.zip -d /usr/local || fail "couldn't unzip ec2-api-tools.zip"
+  chmod -R go-w /usr/local/ec2-api-tools*
+  ln -sf /usr/local/ec2-api-tools-* /usr/local/ec2-api-tools
+  aptitude install -y sun-java6-jre || fail "couldn't install Java package"
+fi
+
+echo "--> Clearing apt cache..."
+aptitude clean
+
+touch /ec2onrails-first-boot || fail
+
+echo "--> Clearing sensitive files..."
+rm -f /root/{.bash_history,.lesshst}
+
+echo "--> Creating image..."
+ec2-bundle-vol -e "/root/.ssh,/home/app/.ssh,/tmp,/mnt" -d /mnt -k "$EC2_PRIVATE_KEY" -c "$EC2_CERT" -u "$AWS_ACCOUNT_ID" || fail "ec2-bundle-vol failed"
+
+echo "--> Uploading image to $NEW_BUCKET_NAME"
+ec2-upload-bundle -b "$NEW_BUCKET_NAME" -m /mnt/image.manifest.xml -a "$AWS_ACCESS_KEY_ID" -s "$AWS_SECRET_ACCESS_KEY" || fail "ec2-upload-bundle failed"
+
+echo "--> Registering image..."
+ec2-register "$NEW_BUCKET_NAME/image.manifest.xml" || fail "ec2-register failed"
+
+echo "--> Done."
+cleanup

data/server/files/usr/local/ec2onrails/bin/restore_app_db.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "rubygems"
+require "optiflag"
+require "fileutils"
+require "#{File.dirname(__FILE__)}/../lib/mysql_helper"
+require "#{File.dirname(__FILE__)}/../lib/s3_helper"
+require "#{File.dirname(__FILE__)}/../lib/utils"
+
+module CommandLineArgs extend OptiFlagSet
+  optional_flag "bucket"
+  optional_flag "dir"
+  and_process!
+end
+
+bucket = ARGV.flags.bucket
+dir = ARGV.flags.dir || "database"
+@s3 = Ec2onrails::S3Helper.new(bucket, dir)
+@mysql = Ec2onrails::MysqlHelper.new
+@temp_dir = "/mnt/tmp/ec2onrails-backup-#{@s3.bucket}-#{dir.gsub(/\//, "-")}"
+if File.exists?(@temp_dir)
+  puts "Temp dir exists (#{@temp_dir}), aborting. Is another backup process running?"
+  exit
+end
+
+begin
+  FileUtils.mkdir_p @temp_dir
+  
+  file = "#{@temp_dir}/dump.sql.gz"
+  @s3.retrieve_file(file)
+  @mysql.load_from_dump(file)
+  
+  @s3.retrieve_files("mysql-bin.", @temp_dir)
+  logs = Dir.glob("#{@temp_dir}/mysql-bin.[0-9]*").sort
+  logs.each {|log| @mysql.execute_binary_log(log) }
+  
+  @mysql.execute_sql "reset master" # TODO  maybe we shouldn't do this if we're not going to delete the logs from the S3 bucket because this restarts the numbering again
+ensure
+  FileUtils.rm_rf(@temp_dir)
+end

data/server/files/usr/local/ec2onrails/bin/set_rails_env

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# This script updates the value of "environment" in the the mongrel_cluster
+# config file.
+
+require "yaml"
+require "erb"
+
+if ARGV.length != 1
+  puts "usage: set_rails_env <value>"
+  exit 1
+end
+
+@rails_env = ARGV[0]
+
+# update mongrel_cluster config
+config = YAML::load_file("/etc/mongrel_cluster/app.yml")
+config["environment"] = @rails_env
+File.open("/etc/mongrel_cluster/app.yml", 'w') do |f|
+  YAML.dump(config, f)
+end