fdlcap 0.3.28

data/lib/fdlcap/recipes/database.rb

@@ -0,0 +1,204 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  set(:create_database_on_cold, true)   
+
+  set(:copy_compression, :gzip) 
+
+  set(:exclude_tables, [])
+
+  # Returns the file extension used for the compression method in
+  # question.
+  def compression_extension
+    case copy_compression
+    when :gzip, :gz   then "tar.gz"
+    when :bzip2, :bz2 then "tar.bz2"
+    when :zip         then "zip"
+    else raise ArgumentError, "invalid compression type #{compression.inspect}"
+    end
+  end
+
+  # Returns the command necessary to compress the given directory
+  # into the given file. The command is returned as an array, where
+  # the first element is the utility to be used to perform the compression.
+  def compress(directory, file)
+    case copy_compression
+    when :gzip, :gz   then ["tar", "czf", file, directory]
+    when :bzip2, :bz2 then ["tar", "cjf", file, directory]
+    when :zip         then ["zip", "-qr", file, directory]
+    else raise ArgumentError, "invalid compression type #{copy_compression.inspect}"
+    end
+  end
+
+  # Returns the command necessary to decompress the given file,
+  # relative to the current working directory. It must also
+  # preserve the directory structure in the file. The command is returned
+  # as an array, where the first element is the utility to be used to
+  # perform the decompression.
+  def decompress(file)
+    case copy_compression
+    when :gzip, :gz   then ["tar", "xzf", file]
+    when :bzip2, :bz2 then ["tar", "xjf", file]
+    when :zip         then ["unzip", "-q", file]
+    else raise ArgumentError, "invalid compression type #{copy_compression.inspect}"
+    end
+  end 
+
+  class Capistrano::Configuration
+    def execute(command, failure_message = "Command failed")
+      puts "Executing: #{command}"
+      system(command) || raise(failure_message)
+    end
+  end
+
+  namespace :database do
+    desc <<-DESC
+    create the production database
+    DESC
+    task :create, :roles => :db do
+      run "cd #{current_path} && rake db:create RAILS_ENV=#{rails_env} --trace"
+    end
+
+    desc "Push db remotely"
+    task :push_db_remotely, :roles => :db do
+
+      default_character_set = Object.const_defined?(:DEFAULT_CHARACTER_SET) ? Object::DEFAULT_CHARACTER_SET : "utf8"
+
+      local_env = ENV['LOCAL_ENV'] || "development"
+
+      all_db_info = YAML.load(File.read("config/database.yml"))
+      local_db_info = all_db_info[local_env]
+      remote_db_info = all_db_info[rails_env.to_s]
+      raise "Missing database.yml entry for #{local_env}" unless local_db_info
+      raise "Missing database.yml entry for #{rails_env.to_s}" unless remote_db_info
+
+
+      puts %{
+
+        ! WARNING !: The remote database '#{remote_db_info["database"]}'
+        will be replaced with the contents of the local database '#{local_db_info["database"]}'.  
+        A dump of the remote db will be placed in your remote home directory just prior 
+        to it being replaced.
+
+        1) current REMOTE_DB ===> backed up to dump file, in ~/
+        2) LOCAL_DB ===> REMOTE_DB ...old REMOTE_DB contents are overwritten!!!
+
+        Even so, this is a very significant and potentially destructive operation.  Please step
+        back and contemplate what you're about to do.
+
+        If you're really sure you want to continue, type "REPLACE #{remote_db_info["database"].upcase}":
+      }
+
+      if ($stdin.gets.strip != "REPLACE #{remote_db_info["database"].upcase}")
+        puts "No action taken, exiting"
+        exit(1)
+      else
+        puts "You confirmed that you want to continue, here we go"
+      end
+
+      dump_file_name = "#{local_db_info["database"]}.sql"
+      local_dump_file_gz_path = "/tmp/#{dump_file_name}.gz"
+
+      execute "time mysqldump -e -q --single-transaction --default_character_set=#{default_character_set} \
+      -u #{local_db_info["username"]} --password=#{local_db_info["password"]} \
+      --database #{local_db_info["database"]} | gzip > #{local_dump_file_gz_path}"
+
+      upload "#{local_dump_file_gz_path}", "#{dump_file_name}.gz", :via => :scp
+
+      execute "echo ^G^G^G^G^G"
+
+      run "gzip -df ~/#{dump_file_name}.gz"
+      run "perl -pi -e 's|#{local_db_info["database"]}|#{remote_db_info["database"]}|g' ~/#{dump_file_name}"
+
+      run "time mysqldump -e -q --single-transaction  --default_character_set=#{default_character_set} \
+      -u #{remote_db_info["username"]} --password=#{remote_db_info["password"]} \
+      --database #{remote_db_info["database"]} | gzip > ~/#{remote_db_info["database"]}_#{Time.now.strftime("%Y-%m-%d_%H-%M-%S")}.sql.gz"
+
+      remote_host = remote_db_info["host"] || "localhost"
+
+      run "mysqladmin -u #{remote_db_info["username"]} --password=#{remote_db_info["password"]} -h #{remote_host} drop #{remote_db_info["database"]} -f"
+      run "mysqladmin -u #{remote_db_info["username"]} --password=#{remote_db_info["password"]} -h #{remote_host} create #{remote_db_info["database"]} --default_character_set=#{default_character_set}"
+      run "time mysql -u #{remote_db_info["username"]} --password=#{remote_db_info["password"]} -h #{remote_host} --database #{remote_db_info["database"]} --default_character_set=#{default_character_set} < ~/#{dump_file_name}"
+      run "rm ~/#{dump_file_name}"
+
+    end
+
+    # ganked from pivotal
+    desc "Pull db locally"
+    task :pull_db_locally, :roles => :db do
+      all_db_info = YAML.load(File.read("config/database.yml"))
+      db_info = all_db_info[rails_env.to_s]
+      raise "Missing database.yml entry for #{rails_env.to_s}" unless db_info
+
+      database = db_info["database"]
+      tables = ENV['TABLES'] ? ENV['TABLES'].split(',').join(' ') : ''
+      dump_file = "/tmp/#{database}.sql"
+      
+      # look to see if a mysqldump process is already running
+      run "ps aux | grep mysqldump | wc -l" do |channel, stream, data|
+        if data.strip.to_i > 2
+          puts "It appears that mysqldump is already running on the server - is another pull task being run?  Aborting to avoid clobbering the dumpfile."
+          exit 1
+        end
+      end
+
+      db_dump_found = false
+      run "if [ -f #{dump_file}.gz ]; then echo exists; else echo not_found; fi" do |channel, stream, data|
+        puts "Result: #{channel[:server]} -> #{dump_file}.gz ( #{data} )"
+        db_dump_found = data.strip == 'exists' ? true : false
+        break if stream == :err
+      end
+
+      db_host = db_info["host"]
+      host = ""
+      host_arg = " -h #{db_host}" if db_host
+      db_dump_cmd = "mysqldump -e -q --single-transaction \
+        -u #{db_info["username"]} --password=#{db_info["password"]} \
+         #{host_arg} #{db_info["database"]} #{tables} | gzip > #{dump_file}.gz"
+
+      if db_dump_found
+        run "ls -l #{dump_file}.gz"
+        puts %{
+          ! INFO !: The remote database dump '#{dump_file}.gz' already exists
+
+          If you would like to use the existing database dump type "USE EXISTING":
+        }
+
+        if ($stdin.gets.strip != "USE EXISTING")
+          puts "Ignoring existing file and regenerating #{dump_file}.gz"
+          run db_dump_cmd
+        else
+          puts "You confirmed that you want to use the existing file [#{dump_file}.gz], here we go"
+        end
+      else
+        run db_dump_cmd
+      end
+
+      get "#{dump_file}.gz", "#{dump_file}.gz"
+      run "rm #{dump_file}.gz" unless ENV['LEAVE_ON_SERVER']
+
+      target_env = ENV['LOCAL_ENV'] || "development"
+      target_db_info = all_db_info[target_env]
+      target_db_login = "-u #{target_db_info["username"]} --password=#{target_db_info["password"]}"
+      target_db_login += " -h #{target_db_info["host"]}" if target_db_info["host"]
+
+      gunzip_cmd = "gunzip -c #{dump_file}.gz"
+      sed_cmd = "sed 's/#{db_info["database"]}/#{target_db_info["database"]}/g' > #{dump_file}"
+      execute("#{gunzip_cmd} | #{sed_cmd}", "gunzip/sed of #{dump_file}.gz failed")
+      unless ENV['TABLES']
+        execute("mysqladmin #{target_db_login} drop #{target_db_info["database"]} -f", "mysqladmin drop failed")
+        execute("mysqladmin #{target_db_login} create #{target_db_info["database"]}", "mysqladmin create failed")
+      end
+      execute("mysql #{target_db_login} --database #{target_db_info["database"]} < #{dump_file}", "mysql import failed")
+      execute("rake db:migrate RAILS_ENV=#{target_env}", "migrate failed")
+      execute("rm #{dump_file}", "rm of local unzipped #{dump_file} failed")
+    end
+  end
+
+  namespace :deploy do
+    task :cold do
+      update
+      database.create if create_database_on_cold
+      migrate
+      start
+    end
+  end
+end

data/lib/fdlcap/recipes/delayed_job.rb

@@ -0,0 +1,28 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :delayed_job do |*args|
+
+    options = args.empty? ? {} : args.first
+    prefix = options[:prefix] || 'dj'
+    set :dj_monit_prefix, prefix unless exists?(:dj_monit_prefix)
+    
+    namespace :delayed_job do
+
+      desc "Start delayed_job"
+      task :start, :only => {:delayed_job => true} do
+        sudo "/usr/bin/monit start all -g #{dj_monit_prefix}_#{application}"
+      end
+      desc "Stop delayed_job"
+      task :stop, :only => {:delayed_job => true} do
+        sudo "/usr/bin/monit stop all -g #{dj_monit_prefix}_#{application}"
+      end
+      desc "Restart delayed_job"
+      task :restart, :only => {:delayed_job => true} do
+        sudo "/usr/bin/monit restart all -g #{dj_monit_prefix}_#{application}"
+      end        
+    end
+  
+    after "deploy:restart", "delayed_job:restart"
+    after "deploy:start",   "delayed_job:start"
+    after "deploy:stop",    "delayed_job:stop"
+  end
+end

data/lib/fdlcap/recipes/deploy.rb

@@ -0,0 +1,26 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  namespace :web do
+    task :disable, :roles => :web, :except => { :no_release => true } do
+      on_rollback { run "rm #{shared_path}/system/maintenance.html" }
+      run "cp #{current_path}/public/maintenance.html #{shared_path}/system/maintenance.html"
+    end
+  end
+  
+  namespace :deploy do
+    desc "Pull files from a remote server"
+    task :download_file, :roles => :app, :except => { :no_release => true } do
+      ENV['FILES'].split(',').each do |file|
+        get "#{current_path}/#{file}", File.basename(file)
+      end
+    end
+  end
+  
+  # Clean up old releases
+  define_recipe :perform_cleanup do
+    after "deploy",                   "deploy:cleanup"
+    after "deploy:migrations" ,       "deploy:cleanup"
+    after "deploy:long" ,             "deploy:cleanup"
+  end
+  
+end

data/lib/fdlcap/recipes/fdl_defaults.rb

@@ -0,0 +1,16 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  define_recipe :fdl_defaults do
+    # defaults for fdl
+    set :scm,           :git
+    set :keep_releases, 5
+    set :deploy_via,    :remote_cache
+    
+    use_recipe :symlinks
+    use_recipe :geminstaller
+    use_recipe :perform_cleanup
+    use_recipe :symlink_configs
+     
+  end
+  
+end

data/lib/fdlcap/recipes/geminstaller.rb

@@ -0,0 +1,53 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :geminstaller do
+    #
+    # Tasks
+    #
+    namespace :geminstaller do
+      desc <<-DESC
+      install geminstaller
+      DESC
+      task :install, :only => { :geminstaller => true } do
+        as = fetch(:runner, "app")
+        via = fetch(:run_method, :sudo)
+        invoke_command "gem install geminstaller", :via => via, :as => as
+        invoke_command "gem source -a http://gems.github.com", :via => via, :as => as
+        invoke_command "gem source -a http://gemcutter.org", :via => via, :as => as
+      end
+
+      desc <<-DESC
+      run geminstaller rake task to install gems on the server
+      DESC
+      task :run, :only => { :geminstaller => true } do
+        as = fetch(:runner, "app")
+        via = fetch(:run_method, :sudo)
+        use_geminstaller_sudo = fetch(:geminstaller_sudo, false)
+        invoke_command  "if ! gem source | grep -q 'http://gemcutter.org' ; then gem source -a 'http://gemcutter.org'; fi", :via => via, :as => as
+        invoke_command  "if ! gem source | grep -q 'http://gems.github.com' ; then gem source -a 'http://gems.github.com'; fi", :via => via, :as => as
+        invoke_command "/usr/bin/geminstaller #{use_geminstaller_sudo ? '-s' : ''} -c #{current_path}/config/geminstaller.yml  --geminstaller-output=all --rubygems-output=all", :via => via, :as => as
+      end
+
+      desc <<-DESC
+      add geminstaller config to list of remote dependencies.
+      DESC
+      task :add_remote_gem_dependencies, :only => { :geminstaller => true } do
+        CONFIG_PATH = File.join('config', 'geminstaller.yml')
+        if File.exists?(CONFIG_PATH)
+          gems = YAML.load(ERB.new(File.read(CONFIG_PATH)).result)['gems']
+          gems.each do |gem|
+            depend :remote, :gem, gem['name'], gem['version']
+          end
+        end
+      end
+    end
+
+    #
+    # Callbacks
+    #
+    before "deploy:check",          "geminstaller:add_remote_gem_dependencies"
+    after  "deploy:setup",          "geminstaller:install"
+    after  "geminstaller:install",  "geminstaller:run"
+    after  "deploy:update",         "geminstaller:run"
+  end
+
+end

data/lib/fdlcap/recipes/newrelic.rb

@@ -0,0 +1,6 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :newrelic do
+    # Tell Newrelic that we've deployed
+    before "deploy:cleanup", "newrelic:notice_deployment"
+  end
+end

data/lib/fdlcap/recipes/nginx.rb

@@ -0,0 +1,102 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  define_recipe :nginx do
+    #
+    # Configuration
+    #
+  
+    # global vars
+    set :can_configure_nginx,   true
+    set :nginx_user,            'nginx'
+    set :nginx_processes,       4
+    set :nginx_gzip_on,         true
+    set :nginx_gzip_xml_on,     false
+
+    # app specific vars
+    set :nginx_server_names,    "_"
+    set :nginx_far_future,      false
+    set :nginx_default_app,     true
+
+    # http auth vars
+    set :nginx_auth_ip_masks,   ['192.168.0.0/254']
+    set :nginx_http_auth_app,   false
+    set :nginx_auth_locations,  []
+    set :nginx_http_auth_users, []
+
+    #
+    # Tasks
+    #
+
+    namespace :nginx do
+
+      %w( start stop restart reload ).each do |cmd|
+        desc "#{cmd} your nginx servers"
+        task "#{cmd}".to_sym, :roles => :app do
+          default_run_options[:pty] = true 
+          sudo "nohup /etc/init.d/nginx #{cmd} > /dev/null"
+        end
+      end   
+  
+      desc "Setup Nginx vhost config"
+      task :vhost, :roles => :web do
+        result = render_erb_template(File.join(File.dirname(__FILE__), '..','templates','nginx.vhost.conf.erb'))
+        put result, "/tmp/nginx.vhost.conf"
+        sudo "mkdir -p /etc/nginx/vhosts"
+        sudo "cp /tmp/nginx.vhost.conf /etc/nginx/vhosts/#{application}.conf"
+        inform "You must edit nginx.conf to include the vhost config file."
+      end
+  
+      desc "Setup Nginx vhost auth config"
+      task :vhost_auth, :roles => :web do
+        result = render_erb_template(File.join(File.dirname(__FILE__), '..','templates','nginx.auth.conf.erb'))
+        put result, "/tmp/nginx.auth.conf"
+        sudo "mkdir -p /etc/nginx/vhosts"
+        sudo "cp /tmp/nginx.vhost.conf /etc/nginx/vhosts/#{application}.auth.conf"
+      end
+  
+      desc "Setup htpasswd file for nginx auth"
+      task  :create_htpasswd, :roles => :web do
+        sudo "mkdir -p /etc/nginx/conf"
+        for user in nginx_http_auth_users
+          run "cd /etc/nginx/conf && htpasswd -b htpasswd #{user['name']} #{user['password']}"
+          # run <<-CMD
+          #       cd /etc/nginx/conf;
+          #       if [ ! -e /etc/nginx/conf/htpasswd ] ; then
+          #           htpasswd -b -c htpasswd #{user['name']} #{user['password']};
+          #       else
+          #           htpasswd -b htpasswd #{user['name']} #{user['password']};
+          #       fi
+          #       CMD
+        end
+      end
+  
+      desc "Setup Nginx.config"
+      task :conf, :roles => :web do
+        if can_configure_nginx
+      
+          result = render_erb_template(File.join(File.dirname(__FILE__),'..','templates','nginx.conf.erb'))
+          put result, "/tmp/nginx.conf"
+          sudo "cp /tmp/nginx.conf /etc/nginx/nginx.conf"
+      
+        else
+          inform "Nginx configuration tasks have been disabled. Most likely you are deploying to engineyard which has it's own nginx conf setup."
+        end
+      end
+  
+      desc "Setup Nginx vhost config and nginx.conf"
+      task :configure, :roles => :web do
+        if can_configure_nginx
+      
+          conf
+          vhost
+          vhost_auth      if nginx_auth_locations.length > 0 || nginx_http_auth_app
+          create_htpasswd if nginx_http_auth_users.length > 0
+      
+        else
+          inform "Nginx configuration tasks have been disabled. Most likely you are deploying to engineyard which has it's own nginx conf setup."
+        end
+      end
+
+    end
+  end
+end

data/lib/fdlcap/recipes/passenger.rb

@@ -0,0 +1,17 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :passenger do
+    namespace :deploy do
+      task :start, :roles => :app do
+        run "touch #{current_release}/tmp/restart.txt"
+      end
+
+      task :stop, :roles => :app do
+        # Do nothing.
+      end
+
+      task :restart, :roles => :app do
+        run "touch #{current_release}/tmp/restart.txt"
+      end
+    end
+  end
+end

data/lib/fdlcap/recipes/performance.rb

@@ -0,0 +1,78 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :autoperf do
+    desc "get nginx log for load test"
+    task :fetch_log, :roles => :app do
+      # Grab the last 1000 requests from production Nginx log, and extract the request path (ex: /index)
+      run "tail -n 1000 /var/log/nginx/#{application}.access.log | awk '{print $7}' > /tmp/requests.log"
+
+      # Replace newlines with null terminator (httperf format)
+      run 'tr "\n" "\0" < /tmp/requests.log > /tmp/requests_httperf.log'
+      
+      download "/tmp/requests_httperf.log", "config/autoperf/requests_httperf.log", :via => :scp
+      
+      run "rm /tmp/requests_httperf.log"
+    end
+    
+    task :run_test, :roles => :app do
+      run "cd #{current_path} && script/autoperf -c config/autoperf/primary.conf" do |channel, stream, data|
+        puts data if stream == :out
+        if stream == :err
+          puts "[Error: #{channel[:host]}] #{data}"
+          break
+        end
+      end
+    end
+  end
+  
+  namespace :autobench do
+    
+    task :run_test, :roles => :app do
+      options = ENV['OPTIONS'] || "--low_rate=1 --high_rate=20 --rate_step=2 --num_call=2 --num_conn=200"
+      run "/usr/local/bin/autobench --single_host --host1=#{ENV['HOST']} --uri1=#{ENV['URL']} --file=/tmp/test.bench.txt #{options}"
+      download "/tmp/test.bench.txt", "autobench/test.bench.txt", :via => :scp
+      run "rm /tmp/test.bench.txt"
+    end
+    
+  end
+  
+  namespace :install do
+
+    task :setup do
+      sudo "rm -rf src"
+      run  "mkdir -p src"
+    end
+
+    desc "Install httperf"
+    task :httperf do
+      setup
+
+      cmd = [
+        "cd src",
+        "wget ftp://ftp.hpl.hp.com/pub/httperf/httperf-0.9.0.tar.gz",
+        "tar xfz httperf-0.9.0.tar.gz",
+        "cd httperf-0.9.0",
+        "./configure --prefix=/usr/local",
+        "make", 
+        "sudo make install"
+        ].join(' && ')
+        run cmd
+        run 'rm httperf-0.9.0.tar.gz'
+    end
+
+    task :autobench do
+      setup
+
+      cmd = [
+        "cd src",
+        "wget http://www.xenoclast.org/autobench/downloads/autobench-2.1.2.tar.gz",
+        "tar xfz autobench-2.1.2.tar.gz",
+        "cd autobench-2.1.2",
+        "make", 
+        "sudo make install"
+        ].join(' && ')
+        run cmd
+        run 'rm autobench-2.1.2.tar.gz'
+    end
+  end
+
+end

data/lib/fdlcap/recipes/rake.rb

@@ -0,0 +1,19 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  desc "Execute an arbitrary rake task on slices with a specified role (ROLES=x,y,z TASK=p)"
+  task :rake do
+    task = ENV['TASK']
+    run "cd #{current_path} && rake #{task} RAILS_ENV=#{rails_env}"
+  end
+
+  desc "Execute an arbitrary runner command on slices with a specified role (ROLES=x,y,z CMD=p)"
+  task :runner do
+    cmd = ENV['CMD']
+    run "cd #{current_path} && script/runner -e #{rails_env} '#{cmd}'"
+  end
+  
+  desc "Execute an arbitrary UNIX command on slices with a specified role (ROLES=x,y,z CMD=p)"
+  task :command do
+    cmd = ENV['CMD']
+    run "cd #{current_path} && #{cmd}"
+  end
+end

data/lib/fdlcap/recipes/rolling_restart.rb

@@ -0,0 +1,31 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :rolling_restart do
+    
+    # Define the rolling_restart task for mongrel
+    namespace :mongrel do
+      desc <<-DESC
+      Do a rolling restart of mongrels, one app server at a time.
+      DESC
+      task :rolling_restart do
+        find_servers(:roles => :app).each do |server|
+          ENV['HOSTS'] = "#{server.host}:#{server.port}"
+          nginx.stop
+          puts "Waiting 10 seconds for mongrels to finish processing on #{ENV['HOSTS']}."
+          sleep 10
+          mongrel.restart
+          puts "Waiting 30 seconds for mongrels to come back up on #{ENV['HOSTS']}."
+          sleep 30
+          nginx.start
+        end
+      end
+    end
+    
+    # Use a rolling restart by default.  Theoretically, if we're doing migrations we should be using deploy:long anyway
+    namespace :deploy do
+      task :restart do
+        mongrel.rolling_restart
+      end
+    end
+    
+  end
+end

data/lib/fdlcap/recipes/rsync.rb

@@ -0,0 +1,42 @@
+class Capistrano::Configuration
+  def execute(command, failure_message = "Command failed")
+    puts "Executing: #{command}"
+    system(command) || raise(failure_message)
+  end
+end
+
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :rsync do
+    desc <<-DESC
+    use rsync to sync assets locally or between servers
+    DESC
+    task :pull_shared , :roles => :app do
+      servers = find_servers :roles => :app, :except => { :no_release => true }
+      server = servers.first
+      if server
+        symlink_dirs.each do |share|
+          `echo '#{password}' | /usr/bin/pbcopy`
+          execute( "rsync -P -a -h -e 'ssh -p #{server.port || 22}' #{user}@#{server.host}:#{shared_path}/#{share}/* #{share}", "unable to run rsync files")
+        end
+      else
+        puts 'no server found'
+      end
+    end
+
+    desc <<-DESC
+    use rsync to sync assets locally or between servers
+    DESC
+    task :push_shared , :roles => :app do
+      servers = find_servers :roles => :app, :except => { :no_release => true }
+      server = servers.first
+      if server
+        symlink_dirs.each do |share|
+          `echo '#{password}' | /usr/bin/pbcopy`
+          execute( "rsync -P -a -h -e 'ssh -p #{server.port || 22}' #{share}/* #{user}@#{server.host}:#{shared_path}/#{share}/", "unable to run rsync files")
+        end
+      else
+        puts 'no server found'
+      end
+    end
+  end
+end

data/lib/fdlcap/recipes/ruby_inline.rb

@@ -0,0 +1,19 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :ruby_inline do
+    
+    #
+    # Tasks
+    #
+    task :ruby_inline, :roles => :app, :except => {:no_release => true, :no_symlink => true} do
+      run "mkdir -p #{release_path}/tmp/ruby_inline/"
+      run "mkdir -p #{release_path}/tmp/ruby_inline/.ruby_inline"
+      sudo "chmod 755 #{release_path}/tmp/ruby_inline/"
+      sudo "chmod 755 #{release_path}/tmp/ruby_inline/.ruby_inline"
+    end
+    
+    #
+    # Callbacks
+    #
+    after "deploy:symlink_configs", "ruby_inline"
+  end
+end

data/lib/fdlcap/recipes/sass.rb

@@ -0,0 +1,20 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  define_recipe :sass do
+    # 
+    # Tasks
+    # 
+    namespace :sass do
+      desc 'Updates the stylesheets generated by Sass'
+      task :update, :roles => :app, :except => { :no_release => true }  do
+        invoke_command "cd #{latest_release}; RAILS_ENV=#{rails_env} rake sass:update"
+      end
+    end
+    
+    #
+    # Callbacks
+    #
+    
+    # Generate all the stylesheets manually (from their Sass templates) before each restart.
+    before 'deploy:restart',          'sass:update'
+  end
+end