fezzik 0.5.2 → 0.6.0

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    fezzik (0.5.2.1)
+      colorize (>= 0.5.8)
+      rake (~> 0.8.7)
+      rake-remote_task (~> 2.0.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    open4 (1.3.0)
+    rake (0.8.7)
+    rake-remote_task (2.0.6)
+      open4 (~> 1.0)
+      rake (~> 0.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fezzik!

data/README.md

@@ -1,120 +1,242 @@
 # Fezzik
 
-Fezzik (or fez) is a slim and snappy alternative to Capistrano.
+Fezzik (or fez) is a slim and snappy way to run commands on servers.
+This is useful for many things, including deployment.
 
-It sets up a rake-based rsync workflow with a single configuration file
-and gets out of your way.
+It wraps a rake-based rsync workflow and tries to keep it simple.
 
 ## Install
 
     gem install fezzik
 
-## Setup
+## Basic setup
 
-    $ cd myproject
-    $ ls
-          server.rb
-    $ fezify
-          [new]  bin/run_app.sh created
-          [new]  config/recipes/core.rb created
-          [new]  config/deploy.rb created
-          [done]
+Require Fezzik in your project Rakefile and define a destination:
 
-**config/deploy.rb**: set your app name and destination servers
+```ruby
+require "fezzik"
 
-    set :app, "fezzik"
-    ...
-    destination :prod do
-      set :domain, "www.fezzik.com"
-    end
+Fezzik.destination :prod do
+  set :domain, "root@myapp.com"
+end
+```
 
-**bin/run_app.sh**: write a command that will start your app
+Write some rake tasks that will execute on the specified destination:
 
-    #!/bin/sh
-    nohup ruby server.rb > /dev/null 2>&1 &
-
-Ready to deploy!
-
-    $ fez prod deploy
-      ...
-      fezzik deployed!
+```ruby
+namespace :fezzik do
+  remote_task :touch do
+    run "touch /tmp/test_file"
+  end
+end
+```
+
+Run your remote_tasks with fezzik:
+
+```
+$ fez prod touch
+```
+
+## Deployments
+
+One of the more useful things you can use Fezzik for is handling deployments.
+
+```ruby
+require "fezzik"
+
+# Fezzik will automatically load any .rake files it finds in this directory.
+Fezzik.init(:tasks => "config/tasks")
+
+# Fezzik wraps rake/remote_task, which is the same rake plugin used by Vlad the Deployer.
+# See http://hitsquad.rubyforge.org/vlad/doco/variables_txt.html for a full list of variables it supports.
+
+set :app, "myapp"
+set :deploy_to, "/opt/#{app}"
+set :release_path, "#{deploy_to}/releases/#{Time.now.strftime("%Y%m%d%H%M")}"
+set :local_path, Dir.pwd
+set :user, "root"
+
+Fezzik.destination :staging do
+  set :domain, "#{user}@myapp-staging.com"
+end
+
+Fezzik.destination :prod do
+  set :domain, "#{user}@myapp.com"
+end
+```
+
+Fezzik comes bundled with some useful rake tasks for common things like deployment.
+You can download the ones you need:
+
+```
+$ cd config/tasks
+$ fez get deploy
+    [new] deploy.rake
+```
+
+You'll need to edit the fezzik:start and fezzik:stop tasks in deploy.rake since those are specific to your
+project.
+
+```ruby
+namespace :fezzik do
+  ...
+  desc "runs the executable in project/bin"
+  remote_task :start do
+    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
+    run "cd #{current_path} && ./bin/run_app.sh"
+  end
+
+  desc "kills the application by searching for the specified process name"
+  remote_task :stop do
+    puts "stopping app"
+    run "(kill `ps aux | grep 'myapp' | grep -v grep | awk '{print $2}'` || true)"
+  end
+  ...
+end
+```
+
+Deploy win!
+
+```
+$ fez prod deploy
+...
+myapp deployed!
+[success]
+```
+
+## Environments
+
+Configuration often changes when you deploy your project. Fezzik lets you set environments for your hosts.
+
+```
+$ cd config/tasks
+$ fez get environment
+    [new] environment.rake
+```
+
+```ruby
+Fezzik.destination :prod do
+  set :domain, "#{user}@myapp.com"
+  Fezzik.env :rack_env, "production"
+end
+```
+
+This will be exposed in the form of an environment.sh file and an environment.rb file in your project root
+directory when you deploy. You can source the .sh file before running your app or require the .rb file in your
+project directly.
+
+```ruby
+  desc "runs the executable in project/bin"
+  remote_task :start do
+    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
+    run "cd #{current_path} && (source environment.sh || true) && ./bin/run_app.sh"
+  end
+```
+
+You can assign different environments to a subset of the hosts you deploy to.
+
+```ruby
+Fezzik.destination :prod do
+  set :domain, ["#{user}@myapp1.com", "#{user}@myapp2.com"]
+  Fezzik.env :rack_env, "production"
+  Fezzik.env :is_canary, "true", :hosts => ["myapp1.com"]
+end
+```
+
+You can access the environment settings in your tasks, if you like. It's a hash.
+
+```ruby
+task :inspect_environment do
+  puts Fezzik.environments.inspect
+end
+```
 
 ## Utilities
 
-Fezzik exposes some utilities that can be useful when running remote tasks.
-
-### Host override
-
-Sometimes you'll want to run a fezzik task on a subset of hosts, rather than the full destination fleet.
-You can override what hosts a fezzik task executes on from the command line.
-
-    # deploy to a single host
-    $ fez prod:domain1.com deploy
+Fezzik exposes some functions that can be useful when running remote tasks.
 
-    # deploy to a single host as root
-    $ fez prod:root@domain1.com deploy
+### Capture or redirect output
 
-    # deploy to multiple hosts
-    $ fez prod:domain1.com,domain2.com deploy
+```ruby
+Fezzik::Util.capture_output(&block)
+```
 
-The overriding hosts don't need to be a subset of the specified destination's domains.
-They can be any hosts you want to use with a destination's configuration.
+Use this function if you would like to hide or capture the normal output that the "run" command prints.
 
-### Capture or redirect output
+```ruby
+remote_task :print_hello
+  # Nothing is printed to stdout
+  server_output = Fezzik::Util.capture_output { run "echo 'hello'"}
 
-    capture_output(&block)
+  # prints "hello"
+  puts server_output
+end
+```
 
-Use this function if you would like to hide or capture the normal output that the "run" command prints.
+### Inspect the target destination
 
-    remote_task :my_task
-      # Nothing is printed to stdout
-      server_output = capture_output { run "echo 'hello'"}
+You can see which destination fezzik is operating on from within your tasks.
 
-      # prints "hello"
-      puts server_output
-    end
+```ruby
+task :print_destination
+  puts Fezzik.target_destination
+end
+```
 
-## Recipes
+## Tasks
 
-Fezzik uses a recipe system similar to Capistrano. Any recipe placed in your config/recipes directory will be
-picked up and available to the fez command. Some useful recipes that are not part of the fezzik core can be
-found in the fezzik project recipes directory. You can download them with fezzik:
+Fezzik has a number of useful tasks other than deploy.rake and environment.rake. These can also be downloaded
+with `$ fez get <task>` and placed in the directory you specify with `Fezzik.init(:tasks => "config/tasks")`.
 
-    fez get <recipes>
+These tasks are meant to be starting points. For example, if you want to save your environment files in a
+place that's not your project root you can simply edit the task in environment.rake.
 
 If you write a recipe that would be useful to other developers, please submit a pull request!
 
 ### Command
 
-    fez get command
+```
+$ cd config/tasks
+$ fez get command
+    [new] command.rake
+```
 
 Sometimes you just need to get your hands dirty and run a shell on your servers.
-The command.rb recipe gives you a prompt that lets you execute shell code on each of your hosts.
+The command.rake tasks give you a prompt that lets you execute shell code on each of your hosts.
 
-    $ fez prod command
-    configuring for root@domain.com
-    run command (or "quit"): tail www/myapp/log.txt -n 1
-    [2011-07-01 00:01:23] GET / 200
+```
+$ fez prod command
+Targeting hosts:
+    root@myapp.com
+run command (or "quit"): tail www/myapp/log.txt -n 1
+[2011-07-01 00:01:23] GET / 200
+```
 
 You can also run a single command:
 
-    $ fez prod command_execute\['ls'\]
-
-(You'll probably need to escape the `[]` in your shell as well.)
+```
+$ fez prod "command_execute[ls]"
+```
 
 ### Rollback
 
-    fez get rollback
+```
+$ cd config/tasks
+$ fez get rollback
+    [new] rollback.rake
+```
 
 Emergency! Rollback! Every deployment you make is saved on the server by default.
 You can move between these deployments (to roll back, for example), with the rollback.rb recipe.
 
-    $ fez prod rollback
-    configuring for root@domain.com
-    === Releases ===
-    0: Abort
-    1: 201107051328 (current)
-    2: 201106231408
-    3: 201106231352
-    Rollback to release (0):
+```
+$ fez prod rollback
+configuring for root@myapp.com
+=== Releases ===
+0: Abort
+1: 201107051328 (current)
+2: 201106231408
+3: 201106231352
+Rollback to release (0):
+```
 

data/Rakefile

@@ -0,0 +1,15 @@
+desc "remove built gems"
+task :clean do
+  sh "rm fezzik-*" rescue true
+end
+
+desc "build gem"
+task :build do
+  sh "gem build fezzik.gemspec"
+end
+
+desc "install gem"
+task :install => [:clean, :build] do
+  sh "gem install `ls fezzik-*`"
+end
+

data/bin/fez

@@ -2,51 +2,87 @@
 
 require "rubygems"
 require "rake"
-require "rake/remote_task"
-require "fezzik"
 require "colorize"
+require "fezzik"
 
-# Include everything in config/recipes
-Dir[File.join(Dir.pwd, 'config/recipes/**/*.rb')].sort.each { |lib| require lib }
+# TODO: Add a handy "fez init" command to set up a basic deployable directory structure
+# TODO: Think about how to do domain overrides better
+# TODO: Add Fezzik::DSL so you can say env or destination instead of Fezzik.env, Fezzik.destination
 
 def usage
   <<-EOF
+Version #{Fezzik::VERSION}
 fez <destination> <tasks>  # Run deployment tasks on destination servers
-fez get <recipes>          # Download recipes to use in your project
+fez get <tasks>            # Download tasks to use in your project
 fez -T                     # Display all tasks
   EOF
 end
 
+def print_usage_and_exit
+  puts usage
+  exit 1
+end
+
 def display_tasks_and_exit
-  Rake.application.options.show_task_pattern = //
-  output = capture_output { Rake.application.display_tasks_and_comments }
+  Rake.application.init
+  Rake.application.load_rakefile
+  Rake.application.options.show_task_pattern = /^fezzik:/
+  output = Fezzik::Util.capture_output { Rake.application.display_tasks_and_comments }
   output.gsub!(/^rake fezzik:/, "fez <destination> ")
   puts output
   exit 0
 end
 
-RECIPE_URL = "https://raw.github.com/dmacdougall/fezzik/master/recipes"
-def download_recipes_and_exit
-  system("mkdir -p config/recipes")
-  ARGV[1..-1].each do |recipe|
-    recipe += ".rb" unless recipe[-3..-1] == ".rb"
-    system("curl -f #{RECIPE_URL}/#{recipe} -o config/recipes/#{recipe} > /dev/null 2>&1")
+TASKS_URL = "https://raw.github.com/dmacdougall/fezzik/master/tasks"
+def download_tasks_and_exit
+  ARGV[1..-1].each do |task|
+    task += ".rake" unless task =~ /\.rake$/
+    system("curl -f #{TASKS_URL}/#{task} -o #{task} > /dev/null 2>&1")
     if $? == 0
-      puts "    [new]".green + "  config/recipes/#{recipe}"
+      puts "    [new]".green + "  #{task}"
     else
-      puts "    [fail]".red + " config/recipes/#{recipe}"
+      puts "    [fail]".red + " #{task}"
     end
   end
   exit 0
 end
 
-if ARGV.size == 0
-  puts usage
-  exit 1
-elsif ARGV[0] == "-T"
-  display_tasks_and_exit
-elsif ARGV[0] == "get"
-  download_recipes_and_exit
+def run_fezzik_tasks
+  ENV["fezzik_destination"] = ARGV[0]
+  Fezzik.init
+  Rake.application.init
+  Rake.application.load_rakefile
+  begin
+    host_list = Array(domain).join("\n    ")
+    puts "Targeting hosts:"
+    puts "    #{host_list}"
+  rescue Rake::ConfigurationError => e
+    puts "Invalid destination: #{Fezzik.target_destination}"
+    puts "Make sure this destination is configured and includes `set :domain, \"yourdomain.com\"`"
+    puts "[fail]".red
+    exit 1
+  end
+  begin
+    tasks = ARGV[1..-1]
+    tasks.each do |task_with_params|
+      task, params = Fezzik::Util.split_task_and_params(task_with_params)
+      Rake::Task["fezzik:#{task}"].invoke(params)
+    end
+    puts "[success]".green
+  rescue SystemExit, Rake::CommandFailedError => e
+    puts "[fail]".red
+    exit 1
+  rescue StandardError => e
+    puts e.message
+    puts e.backtrace
+    puts "[fail]".red
+    fail
+  end
 end
 
-Rake.application["fezzik:run"].invoke
+case ARGV[0]
+when nil then print_usage_and_exit
+when "-T" then display_tasks_and_exit
+when "get" then download_tasks_and_exit
+else run_fezzik_tasks
+end

data/fezzik.gemspec

@@ -13,19 +13,14 @@ Gem::Specification.new do |s|
   s.email = "dmacdougall@gmail.com"
 
   s.description = "A light deployment system that gets out of your way"
-  s.summary = "A light deployment system that gets out of your way"
+  s.summary = "Fezzik is a small wrapper around rake/remote_task. It simplifies running commands on" +
+      "remote servers and can be used for anything from deploying code to installing libraries remotely."
   s.homepage = "http://github.com/dmacdougall/fezzik"
   s.rubyforge_project = "fezzik"
 
   s.executables = %w(fez fezify)
-  s.files = %w(
-    README.md
-    TODO.md
-    fezzik.gemspec
-    lib/fezzik.rb
-    bin/fez
-    bin/fezify
-  )
+  s.files = `git ls-files`.split("\n")
+
   s.add_dependency("rake", "~>0.8.7")
   s.add_dependency("rake-remote_task", "~>2.0.2")
   s.add_dependency("colorize", ">=0.5.8")

data/lib/fezzik.rb

@@ -1,100 +1,10 @@
 require "stringio"
 require "thread"
-
-# Synchronize 'puts' because it's annoying to have interleaved output when rake remote task is running
-# several things at once in multiple threads (for instance: commands on multiple servers or commands as
-# multiple users).
-class IO
-  @@print_mutex = Mutex.new
-  alias :old_puts :puts
-  def puts(*args) @@print_mutex.synchronize { old_puts(*args) } end
-end
-
-namespace :fezzik do
-  task :run do
-    destination = ARGV[0]
-    destination = $1 if destination.match(/^to_(.+)/)
-    destination, @domain_override = destination.split(":", 2)
-    @domain_override = @domain_override.split(",") if @domain_override
-    tasks = ARGV[1..-1]
-    Rake::Task["fezzik:load_config"].invoke destination
-    begin
-      tasks.each do |task|
-        task, params = split_task_and_params(task)
-        Rake::Task["fezzik:#{task}"].invoke(*params)
-      end
-      puts "[success]".green
-    rescue SystemExit, Rake::CommandFailedError => e
-      puts "[fail]".red
-      exit 1
-    rescue Exception => e
-      puts e.message
-      puts e.backtrace
-      puts "[fail]".red
-      fail
-    end
-  end
-
-  task :load_config, :destination do |t, args|
-    @destination = args[:destination].to_sym
-    @environment = {}
-    require "./config/deploy.rb"
-    @servers = domain.is_a?(Array) ? domain : domain.split(",").map(&:strip)
-    compute_environment_per_server
-    puts "configuring for #{@servers.join(", ")}"
-  end
-
-  def destination(target, &block)
-    if target == @destination
-      block.call
-      if @domain_override
-        @domain_override.map! { |domain| domain.include?("@") ? domain : "#{user}@#{domain}" }
-        set :domain, @domain_override
-      end
-    end
-  end
-
-  # If servers is given, then this environment variable will only apply to that server (or array of servers)
-  # (these should match names given in :domain). If servers is not given, then this environment variable
-  # applies to all servers.
-  def env(key, value, servers = nil)
-    servers = Array(servers) if servers
-    @environment[[key, servers]] = value
-  end
-
-  def compute_environment_per_server
-    @per_server_environments = Hash.new { |h, k| h[k] = {} }
-    @environment.each do |k, value|
-      key, servers = k
-      if servers
-        # Allow the user to provide "user@host.com" or "host.com" when identifying servers for per-server
-        # environment variables.
-        applicable_servers = @servers.select { |s1| servers.any? { |s2| s1 == s2 || s1.end_with?(s2) } }
-      else
-        applicable_servers = @servers
-      end
-      applicable_servers.each { |s| @per_server_environments[s][key] = value }
-    end
-  end
-
-  def capture_output(&block)
-    output = StringIO.new
-    $stdout = output
-    block.call
-    return output.string
-  ensure
-    $stdout = STDOUT
-  end
-
-  def split_task_and_params(task_with_params)
-    params_match = /(.+)\[(.+)\]/.match(task_with_params)
-    if params_match
-      task = params_match[1]
-      params = params_match[2].split(",")
-    else
-      task = task_with_params
-      params = nil
-    end
-    [task, params]
-  end
-end
+require "rake"
+require "rake/remote_task"
+require "colorize"
+require "fezzik/base.rb"
+require "fezzik/environment.rb"
+require "fezzik/io.rb"
+require "fezzik/util.rb"
+require "fezzik/version.rb"

data/lib/fezzik/base.rb

@@ -0,0 +1,19 @@
+module Fezzik
+  def self.init(options={})
+    @options = options
+    @target_destination = ENV["fezzik_destination"].to_sym rescue nil
+    unless options[:tasks].nil?
+      puts "Loading Fezzik tasks from #{@options[:tasks]}"
+      Dir[File.join(Dir.pwd, "#{@options[:tasks]}/**/*.rake")].sort.each { |lib| import lib }
+    end
+  end
+
+  # TODO: add domain override (through environment variable?)
+  def self.destination(name, &block)
+    block.call if name == @target_destination
+  end
+
+  def self.target_destination
+    @target_destination ||= nil
+  end
+end

data/lib/fezzik/environment.rb

@@ -0,0 +1,14 @@
+module Fezzik
+  def self.env(key, value, options={})
+    options = {
+      :hosts => domain
+    }.merge(options)
+    options[:hosts] = Array(options[:hosts])
+    @environments ||= Hash.new { |h, k| h[k] = {} }
+    options[:hosts].each { |host| @environments[host][key] = value }
+  end
+
+  def self.environments
+    @environments ||= Hash.new { |h, k| h[k] = {} }
+  end
+end

data/lib/fezzik/io.rb

@@ -0,0 +1,9 @@
+# Synchronize 'puts' because it's annoying to have interleaved output when rake remote task is running
+# several things at once in multiple threads (for instance: commands on multiple servers or commands as
+# multiple users).
+class IO
+  @@print_mutex = Mutex.new
+  alias :old_puts :puts
+  def puts(*args) @@print_mutex.synchronize { old_puts(*args) } end
+end
+

data/lib/fezzik/util.rb

@@ -0,0 +1,24 @@
+module Fezzik
+  module Util
+    def self.capture_output(&block)
+      output = StringIO.new
+      $stdout = output
+      block.call
+      return output.string
+    ensure
+      $stdout = STDOUT
+    end
+
+    def self.split_task_and_params(task_with_params)
+      params_match = /(.+)\[(.+)\]/.match(task_with_params)
+      if params_match
+        task = params_match[1]
+        params = params_match[2].split(",")
+      else
+        task = task_with_params
+        params = nil
+      end
+      [task, params]
+    end
+  end
+end

data/lib/fezzik/version.rb

@@ -0,0 +1,3 @@
+module Fezzik
+  VERSION = "0.6.0"
+end

data/tasks/command.rake

@@ -0,0 +1,37 @@
+# Tasks for running commands on destination hosts.
+#
+# Tasks:
+#  * command: interactively run commands on destination servers
+#  * command_execute: run a single command on destination servers
+#
+namespace :fezzik do
+  desc "interactively run commands on destination servers"
+  task :command do
+    loop do
+      print "run command (or \"quit\"): "
+      STDOUT.flush
+      input = STDIN.gets
+      # Exit gracefully on <C-D>
+      if input.nil?
+        puts
+        break
+      end
+      command = input.chomp
+      next if command.empty?
+      if ["quit", "q", "exit"].include? command.downcase
+        break
+      else
+        begin
+          Rake::Task["fezzik:command_execute"].invoke command
+        rescue Rake::CommandFailedError
+        ensure
+          Rake::Task["fezzik:command_execute"].reenable
+        end
+      end
+    end
+  end
+
+  desc "run a single command on destination servers"
+  remote_task(:command_execute, :command) { |t, args| run args[:command] }
+end
+

data/tasks/deploy.rake

@@ -0,0 +1,60 @@
+require "fileutils"
+
+namespace :fezzik do
+  desc "stages the project for deployment in /tmp"
+  task :stage do
+    puts "staging project in /tmp/#{app}"
+    FileUtils.rm_rf "/tmp/#{app}"
+    FileUtils.mkdir_p "/tmp/#{app}/staged"
+    # Use rsync to preserve executability and follow symlinks.
+    system("rsync -aqE #{local_path}/. /tmp/#{app}/staged")
+  end
+
+  desc "performs any necessary setup on the destination servers prior to deployment"
+  remote_task :setup do
+    puts "setting up servers"
+    run "mkdir -p #{deploy_to}/releases"
+  end
+
+  desc "rsyncs the project from its staging location to each destination server"
+  remote_task :push => [:stage, :setup] do
+    puts "pushing to #{target_host}:#{release_path}"
+    # Copy on top of previous release to optimize rsync
+    rsync "-q", "--copy-dest=#{current_path}", "/tmp/#{app}/staged/", "#{target_host}:#{release_path}"
+  end
+
+  desc "symlinks the latest deployment to /deploy_path/project/current"
+  remote_task :symlink do
+    puts "symlinking current to #{release_path}"
+    run "cd #{deploy_to} && ln -fns #{release_path} current"
+  end
+
+  desc "runs the executable in project/bin"
+  remote_task :start do
+    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
+    run "cd #{current_path} && (source config/environment.sh || true) && ./bin/run_app.sh"
+  end
+
+  desc "kills the application by searching for the specified process name"
+  remote_task :stop do
+    # Replace YOUR_APP_NAME with whatever is run from your bin/run_app.sh file.
+    # If you'd like to do this nicer you can save the PID of your process with `echo $! > app.pid`
+    # in the start task and read the PID to kill here in the stop task.
+    # puts "stopping app"
+    # run "(kill -9 `ps aux | grep 'YOUR_APP_NAME' | grep -v grep | awk '{print $2}'` || true)"
+  end
+
+  desc "restarts the application"
+  remote_task :restart do
+    Rake::Task["fezzik:stop"].invoke
+    Rake::Task["fezzik:start"].invoke
+  end
+
+  desc "full deployment pipeline"
+  task :deploy do
+    Rake::Task["fezzik:push"].invoke
+    Rake::Task["fezzik:symlink"].invoke
+    Rake::Task["fezzik:restart"].invoke
+    puts "#{app} deployed!"
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,42 @@
+require "fileutils"
+
+# Any variables set in deploy.rb with `Fezzik.env` will be saved on the server in two files:
+# environment.sh and environment.rb. The first can be loaded into the shell environment before the run script
+# is called, and the second is made available to be required into your code. You can use your own
+# environment.rb file for development and it will be overwritten by this task when the code deploys.
+namespace :fezzik do
+  desc "saves variables set by `Fezzik.env` into a local staging area before deployment"
+  task :save_environment do
+    Fezzik.environments.each do |server, environment|
+      root_config_dir = "/tmp/#{app}/#{server}_config"
+      FileUtils.mkdir_p root_config_dir
+      File.open(File.join(root_config_dir, "environment.rb"), "w") do |file|
+        environment.each do |key, value|
+          quote = value.is_a?(Numeric) ? '' : '"'
+          file.puts "#{key.to_s.upcase} = #{quote}#{value}#{quote}"
+        end
+      end
+      File.open(File.join(root_config_dir, "environment.sh"), "w") do |file|
+        environment.each { |key, value| file.puts %[export #{key.to_s.upcase}="#{value}"] }
+      end
+    end
+  end
+
+  # Append to existing actions defined in deploy.rake. This works because we import .rake files alphabetically,
+  # so the tasks defined in deploy.rake will be executed before these defined in environment.rake.
+  # TODO: Can these be handled through dependencies?
+  # task :stage => :save_environment
+  # task :push => :push_config
+  task :stage do
+    Rake::Task["fezzik:save_environment"].invoke
+  end
+
+  task :push do
+    # Copy over the appropriate configs for the target
+    server = target_host.gsub(/^.*@/, "")
+    ["environment.rb", "environment.sh"].each do |config_file|
+      rsync "-q", "/tmp/#{app}/#{server}_config/#{config_file}",
+            "#{target_host}:#{release_path}/#{config_file}"
+    end
+  end
+end

data/tasks/rollback.rake

@@ -0,0 +1,54 @@
+# Tasks for handling deployment rollbacks.
+#
+# Tasks:
+#  * rollback: interactively rollback (or forward) your live deployment
+#  * rollback_one: rollback to previous deployment
+#  * rollback_to_release: rollback to a specific deployment
+#
+namespace :fezzik do
+  desc "interactively roll back deployment"
+  task :rollback do
+    target_domain = domain.is_a?(Array) ? domain.first : domain
+    releases = `ssh #{target_domain} "cd #{File.dirname(release_path)} && ls"`.split(/\s+/).reverse
+    current_release = File.basename(`ssh #{target_domain} "cd #{deploy_to} && readlink current"`).strip
+    puts "=== Releases ==="
+    puts "0: Abort"
+    releases.each_index { |i| puts "#{i+1}: #{releases[i]} #{releases[i] == current_release ? "(current)" : ""}" }
+    print "Rollback to release (0): "
+    STDOUT.flush
+    release_num = STDIN.gets.chomp.to_i
+
+    unless release_num > 0 && release_num <= releases.size
+      puts "rollback aborted"
+      exit 1
+    end
+
+    selected_release = releases[release_num-1]
+    Rake::Task["fezzik:rollback_to_release"].invoke(selected_release)
+  end
+
+  desc "rolls back deployment to the previous release"
+  task :rollback_one do
+    target_domain = domain.is_a?(Array) ? domain.first : domain
+    current_release = File.basename(`ssh #{target_domain} "cd #{deploy_to} && readlink current"`).strip
+    previous_release = %x{
+        ssh #{target_domain} "cd #{File.dirname(release_path)} && ls | grep "#{current_release}" -B 1 | head -1"
+    }.strip
+
+    if previous_release == current_release
+      puts "already at oldest deploy, unable to rollback"
+      exit 1
+    end
+
+    Rake::Task["fezzik:rollback_to_release"].invoke(previous_release)
+  end
+
+  desc "rolls back deployment to a specific release"
+  remote_task :rollback_to_release, :selected_release do |t, args|
+    selected_release = args[:selected_release]
+    puts "rolling #{target_host} back to #{selected_release}"
+    run "cd #{deploy_to} && ln -fns #{File.dirname(release_path)}/#{selected_release} current"
+    Rake::Task["fezzik:restart"].invoke
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fezzik
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-05 00:00:00.000000000Z
+date: 2012-02-09 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152263900 !ruby/object:Gem::Requirement
+  requirement: &2152662480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 0.8.7
   type: :runtime
   prerelease: false
-  version_requirements: *2152263900
+  version_requirements: *2152662480
 - !ruby/object:Gem::Dependency
   name: rake-remote_task
-  requirement: &2152263440 !ruby/object:Gem::Requirement
+  requirement: &2152662020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 2.0.2
   type: :runtime
   prerelease: false
-  version_requirements: *2152263440
+  version_requirements: *2152662020
 - !ruby/object:Gem::Dependency
   name: colorize
-  requirement: &2152262980 !ruby/object:Gem::Requirement
+  requirement: &2152661560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,7 +44,7 @@ dependencies:
         version: 0.5.8
   type: :runtime
   prerelease: false
-  version_requirements: *2152262980
+  version_requirements: *2152661560
 description: A light deployment system that gets out of your way
 email: dmacdougall@gmail.com
 executables:
@@ -53,12 +53,25 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
 - README.md
+- Rakefile
 - TODO.md
-- fezzik.gemspec
-- lib/fezzik.rb
 - bin/fez
 - bin/fezify
+- fezzik.gemspec
+- lib/fezzik.rb
+- lib/fezzik/base.rb
+- lib/fezzik/environment.rb
+- lib/fezzik/io.rb
+- lib/fezzik/util.rb
+- lib/fezzik/version.rb
+- tasks/command.rake
+- tasks/deploy.rake
+- tasks/environment.rake
+- tasks/rollback.rake
 homepage: http://github.com/dmacdougall/fezzik
 licenses: []
 post_install_message: 
@@ -82,5 +95,7 @@ rubyforge_project: fezzik
 rubygems_version: 1.8.7
 signing_key: 
 specification_version: 2
-summary: A light deployment system that gets out of your way
+summary: Fezzik is a small wrapper around rake/remote_task. It simplifies running
+  commands onremote servers and can be used for anything from deploying code to installing
+  libraries remotely.
 test_files: []