vlad 1.0.0 → 1.1.0

data/History.txt

@@ -1,5 +1,30 @@
+== 1.1.0 / 2007-09-12
+
+* 3 major enhancements:
+  * Vlad.load now takes a hash of recipe overrides, eg: Vlad.load :web => :nginx.
+    See rdoc for defaults.
+  * Removed vlad_tasks.rb and split into vlad/apache.rb, vlad/mongrel.rb,
+    and vlad/core.rb.
+  * The flog ratio between capistrano+deps / vlad+deps is pi (or, damn close)!
+* 12 minor enhancements:
+  * Added $TRACE to make it more available and cleaner to read.
+  * Added :svn_cmd variable.
+  * Added Rake.clear_tasks *str_or_regexp
+  * Added debug and mana_from_heaven tasks to Rakefile.
+  * Added more documentation.
+  * Added :rsync_cmd and :rsync_flags.
+  * Added :ssh_cmd and :ssh_flags.
+  * Added variable expansion to vlad:debug task.
+  * Removed :scm variable. Now a Vlad.load component/flavor/need-a-word-here.
+  * Removed :application var. Use it if you want it. We don't require it.
+  * Renamed :p4cmd to :p4_cmd.
+  * Renamed :rake var to :rake_cmd.
+* 2 (important) bug fixes:
+  * HUGE: Fixed sudo hang bug #13072.  Fix suggested by Chris Van Pelt.
+  * HUGE: Vlad.load calls user config last, allowing variable overrides.
+    ACK! Sorry!
+
 == 1.0.0 / 2007-08-04
 
 * 1 major enhancement
   * Birthday!
-

data/Manifest.txt

@@ -3,15 +3,18 @@ Manifest.txt
 README.txt
 Rakefile
 considerations.txt
+doco/faq.txt
 doco/getting_started.txt
 doco/migration.txt
 doco/perforce.txt
 doco/variables.txt
 lib/rake_remote_task.rb
 lib/vlad.rb
+lib/vlad/apache.rb
+lib/vlad/core.rb
+lib/vlad/mongrel.rb
 lib/vlad/perforce.rb
 lib/vlad/subversion.rb
-lib/vlad_tasks.rb
 test/test_rake_remote_task.rb
 test/test_vlad.rb
 test/test_vlad_perforce.rb

data/README.txt

@@ -15,27 +15,24 @@ Impale your application on the heartless spike of the Deployer.
 == FEATURES/PROBLEMS:
 
 * Full deployment automation stack.
-* Supports single server deployment with just 4 variables defined.
+* Turnkey deployment for mongrel+apache+svn.
+* Supports single server deployment with just 3 variables defined.
+* Built on rake. Easy. Engine is small.
 * Very few dependencies. All simple.
 * Uses ssh with your ssh settings already in place.
 * Uses rsync for efficient transfers.
 * Run remote commands on one or more servers.
-* Syncs files to one or more servers.
 * Mix and match local and remote tasks.
-* Built on rake. easy.
 * Compatible with all of your tab completion shell script rake-tastic goodness.
-* Ships with tests that actually pass.
-* Engine is under 500 lines of code.
-* Super uper simple.
-* Does NOT support Windows right now. Coming soon in 1.1.
-* This is 1.0.0... expect rough edges.
+* Ships with tests that actually pass in 0.028 seconds!
+* Does NOT support Windows right now (we think). Coming soon in 1.2.
 
 == SYNOPSIS:
 
-    rake vlad:setup   # first time only
-    rake vlad:update
-    rake vlad:migrate # optional
-    rake vlad:start
+    % rake vlad:setup   # first time only
+    % rake vlad:update
+    % rake vlad:migrate # optional
+    % rake vlad:start
 
 == REQUIREMENTS:
 

data/Rakefile

@@ -11,17 +11,41 @@ Hoe.new('vlad', Vlad::VERSION) do |p|
   p.email = "ryand-ruby@zenspider.com"
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/).map { |s| s.strip }[2..-1]
   p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.summary = p.paragraphs_of('README.txt', 2).join
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   p.extra_deps << 'rake'
   p.extra_deps << 'open4'
 end
 
+desc "quick little hack to see what the state of the nation looks like"
+task :debug do
+  Vlad.load :config => "lib/vlad/subversion.rb"
+  set :repository, "repository path"
+  set :deploy_to,  "deploy path"
+  set :domain,     "server domain"
+
+  Rake::Task['vlad:debug'].invoke
+end
+
 task :flog do
-  sh 'find lib -name \*.rb | grep -v vlad_tasks | xargs flog | head -1'
+  sh 'flog -s lib'
 end
 
 task :flog_full do
-  sh 'find lib -name \*.rb | xargs flog -a'
+  sh 'flog -a lib'
+end
+
+task :mana_from_heaven do
+  # vlad = vlad + rake + open4
+  # rake sans-contrib = 2035.98356718206
+  vlad  = `flog -s lib`.to_f + 2350.30744806517 + 502.363818023761
+  cap   = 11480.3919695285
+  ratio = cap / vlad
+  target = cap / Math::PI
+
+  puts "%14.8f = %s" % [vlad, "vlad"]
+  puts "%14.8f = %s" % [ratio, "ratio"]
+  puts "%14.8f = %s" % [target - vlad, "needed delta"]
 end
 
 # vim: syntax=Ruby

data/doco/faq.txt

@@ -0,0 +1,75 @@
+== Rake & Recipes
+
+=== Q: Why is there no vlad:restart?
+=== A: It is cleaner!
+
+We don't want to have to think about what state we're in and where. So vlad:start does a restart if necessary. Restart is just "start again" after all... That is what start does.
+
+=== Q: Why are there no before_action and after_action hooks?
+=== A: Because we use rake!
+
+Rake don't need no stinkin' hooks! They're too clever. Last I checked before_after_before_start worked in cap... how? why? I dunno...
+
+To extend a task (adding something after), just define it again:
+
+  task :action1 do
+    puts "one fish, two fish"
+  end
+
+  task :action1 do
+    puts "red fish, blue fish"
+  end
+
+To prepend on a task, add a dependency:
+
+  task :action2 do
+    puts "red fish, blue fish"
+  end
+
+  task :myaction do
+    puts "one fish, two fish"
+  end
+
+  task :action2 => :myaction
+
+=== Q: How do I invoke another rule?
+=== A: The easiest way is via dependencies.
+
+  task :shazam! => [:action1, :action2]
+
+ The other way is to look it up and call invoke:
+
+  task :shazam! do
+    Rake::Task[:action1].invoke
+    Rake::Task[:action2].invoke
+  end
+
+(Or, cheat and call out to rake again: sh "rake action1")
+
+== Using SSH
+
+=== Q: Is there any way to set the ssh user?
+=== A: Yes, using ~/.ssh/config
+
+  Host example.com
+    User fluffy_bunny
+
+OR: Alternatively, you can do this within your recipes like so:
+
+  set :user, "fluffy_bunny"
+  set :domain, "#{user}@example.com"
+
+=== Q: Is there any way to speed up ssh connections?
+=== A: Yes, add to your Host entry in ~/.ssh/config:
+
+  ControlMaster auto
+  ControlPath ~/.ssh/master-%r@%h:%p
+
+=== Q: I'm tired of typing in my password!
+=== A: Me too!
+
+Put a password on your key, distribute your public key to the server and then use ssh-agent.
+
+Check out this tiny tutorial at LBL: A brief ssh-agent tutorial <http://upc.lbl.gov/docs/user/sshagent.html>
+
+If you're on a mac, use SSHKeychain, we love it. <http://www.sshkeychain.org/>

data/doco/getting_started.txt

@@ -16,12 +16,26 @@ refer to the variable documentation.
 
 * Add the following to your Rakefile:
 
-    require 'vlad'
-    Vlad.load 'config/deploy.rb'
+    begin
+      require 'vlad'
+      Vlad.load
+    rescue LoadError
+      # do nothing
+    end
 
-* <tt>rake vlad:setup</tt>
+Vlad.load has a lot of flexibility. See the rdoc for full information.
 
-=== Launch
+You don't need the begin/rescue/end block if you ensure that Vlad is
+installed on all your servers. To be lazy, you can install vlad via:
+
+    % rake vlad:invoke COMMAND='sudo gem install vlad -y'
+
+=== Initial Launch
+
+* Run <tt>rake vlad:setup vlad:update vlad:migrate vlad:start</tt>
+
+=== Subsequent Updates:
 
 * <tt>rake vlad:update vlad:migrate vlad:start</tt>
 
+Each step may be run separately.

data/doco/migration.txt

@@ -1,5 +1,6 @@
 == Converting from Capistrano
 
+* 'set scm' is removed. Vlad.load :scm => :something if you don't use subversion.
 * 'task' blocks are renamed to 'remote_task'.
 * Most variables are the same. See variables.txt for details.
 * No +with_command+ / +sudo+ / +via+ wonkiness
@@ -19,3 +20,24 @@
   - host "www.example.com", :app, :web, :db
     specifies a host with three roles.
 * migrate_env is now migrate_args.
+* Vlad doesn't have before/after magic add-on tasks.
+
+== BEFORE:
+
+  set :application, "rubyholic"
+  set :domain,      "zenspider.textdriven.com"
+  set :repository,  "svn://svn.example.com/rubyholic/branches/stable"
+  set :deploy_to,   "/users/home/zenspider/domains/new.rubyholic.com"
+  
+  set :user,        "zenspider"
+  set :use_sudo,    false
+  
+  role :web, domain
+  role :app, domain
+  role :db,  domain, :primary => true
+
+== AFTER:
+
+  set :domain,      "zenspider.textdriven.com"
+  set :repository,  "svn://svn.example.com/rubyholic/branches/stable"
+  set :deploy_to,   "/users/home/zenspider/domains/new.rubyholic.com"

data/doco/variables.txt

@@ -1,7 +1,6 @@
 
-== Variables
+== Core Variables
 
-application::          REQUIRED: Name of your application. e.g. hitsquad
 repository::           REQUIRED: Repository path: e.g. http://repo.example.com/svn
 deploy_to::            REQUIRED: Deploy path on target machines. e.g. /var/www/app
 domain::               REQUIRED: Used for the common case of a single target
@@ -32,13 +31,46 @@ releases::             An array of all existing releases, oldest first.
                        Defaults to latest release directory name.
 releases_path::        Full path to the 'releases' directory on the remote host.
                        Defaults to "#{deploy_to}/releases".
-scm::                  Which SCM module to use. Valid options are :subversion
-                       and :perforce as of 1.0. Defaults to "subversion"
+rsync_cmd::            Path to rsync command. Defaults to "rsync".
+rsync_flags::          Flags for rsync. Defaults to ['-azP', '--delete'].
 scm_path::             Path on the remote host that will be used as 'working
                        space' for SCM tasks. Defaults to "#{deploy_to}/scm".
-sudo_password::        Asks for password when referenced.
-source::               Read-Only: An SCM worker instance defined by scm.
 shared_path::          Full path to remote 'shared' directory, symlinked into
                        your app by default. Defaults to "#{deploy_to}/shared".
+ssh_cmd::              Path to ssh. Defaults to "ssh".
+ssh_flags::            Flags for ssh. Defaults to "".
+sudo_cmd::             Path to sudo command. Defaults to "sudo".
+sudo_flags::           Flogs for sudo. Defaults to nil.
+sudo_password::        Asks for password when referenced.
+
+== Apache Web Variables:
+
 web_command::          Command to execute when controlling the web server.
                        Defaults to "apachectl".
+
+== Mongrel App Variables:
+
+mongrel_address::       Defaults to "127.0.0.1"
+mongrel_clean::         Defaults to false
+mongrel_command::       Defaults to 'mongrel_rails'
+mongrel_conf::          Defaults to "#{shared_path}/mongrel_cluster.conf"
+mongrel_config_script:: Defaults to nil
+mongrel_environment::   Defaults to "production"
+mongrel_group::         Defaults to nil
+mongrel_log_file::      Defaults to nil
+mongrel_pid_file::      Defaults to nil
+mongrel_port::          Defaults to 8000
+mongrel_prefix::        Defaults to nil
+mongrel_servers::       Defaults to 2
+mongrel_user::          Defaults to nil
+
+== Perforce SCM Variables:
+
+p4_cmd::                The perforce command to use. Defaults to "p4"
+source::                A perforce SCM worker instance.
+
+== Subversion SCM Variables:
+
+source::                A subversion SCM worker instance.
+svn_cmd::               The subversion command to use. Defaults to "svn"
+

data/lib/rake_remote_task.rb

@@ -1,10 +1,91 @@
 require 'rubygems'
 require 'open4'
+require 'rake'
 require 'vlad'
 
+$TESTING ||= false
+$TRACE = Rake.application.options.trace
+
+module Rake
+  module TaskManager
+    ##
+    # This gives us access to the tasks already defined in rake.
+    def all_tasks
+      @tasks
+    end
+  end
+
+  ##
+  # Hooks into rake and allows us to clear out a task by name or
+  # regexp. Use this if you want to completely override a task instead
+  # of extend it.
+  def self.clear_tasks(*tasks)
+    tasks.flatten.each do |name|
+      case name
+      when Regexp then
+        Rake.application.all_tasks.delete_if { |k,_| k =~ name }
+      else
+        Rake.application.all_tasks.delete(name)
+      end
+    end
+  end
+end
+
 ##
-# Rake::RemoteTask is a subclass of Rake::Task that adds remote_actions that
-# execute in parallel on multiple hosts via ssh.
+# Declare a remote host and its roles. Equivalent to <tt>role</tt>,
+# but shorter for multiple roles.
+def host host_name, *roles
+  Rake::RemoteTask.host host_name, *roles
+end
+
+##
+# Declare a Vlad task that will execute on all hosts by default. To
+# limit that task to specific roles, use:
+#
+#     remote_task :example, :roles => [:app, :web] do
+def remote_task name, options = {}, &b
+  Rake::RemoteTask.remote_task name, options, &b
+end
+
+##
+# Declare a role and assign a remote host to it. Equivalent to the
+# <tt>host</tt> method; provided for capistrano compatibility.
+def role role_name, host, args = {}
+  Rake::RemoteTask.role role_name, host, args
+end
+
+##
+# Execute the given command on the <tt>target_host</tt> for the
+# current task.
+def run *args, &b
+  Thread.current[:task].run(*args, &b)
+end
+
+# rsync the given files to <tt>target_host</tt>.
+def rsync local, remote
+  Thread.current[:task].rsync local, remote
+end
+
+# Declare a variable called +name+ and assign it a value. A
+# globally-visible method with the name of the variable is defined.
+# If a block is given, it will be called when the variable is first
+# accessed. Subsequent references to the variable will always return
+# the same value. Raises <tt>ArgumentError</tt> if the +name+ would
+# conflict with an existing method.
+def set name, val = nil, &b
+  Rake::RemoteTask.set name, val, &b
+end
+
+# Returns the name of the host that the current task is executing on.
+# <tt>target_host</tt> can uniquely identify a particular task/host
+# combination.
+def target_host
+  Thread.current[:task].target_host
+end
+
+##
+# Rake::RemoteTask is a subclass of Rake::Task that adds
+# remote_actions that execute in parallel on multiple hosts via ssh.
 
 class Rake::RemoteTask < Rake::Task
 
@@ -21,8 +102,8 @@ class Rake::RemoteTask < Rake::Task
   attr_accessor :target_host
 
   ##
-  # An Array of Actions this host will perform during execution.  Use enhance
-  # to add new actions to a task.
+  # An Array of Actions this host will perform during execution. Use
+  # enhance to add new actions to a task.
 
   attr_reader :remote_actions
 
@@ -35,12 +116,12 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # Add a local action to this task.  This calls Rake::Task#enhance.
+  # Add a local action to this task. This calls Rake::Task#enhance.
 
   alias_method :original_enhance, :enhance
 
   ##
-  # Add remote action +block+ to this task with dependencies +deps+.  See
+  # Add remote action +block+ to this task with dependencies +deps+. See
   # Rake::Task#enhance.
 
   def enhance(deps=nil, &block)
@@ -50,12 +131,14 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # Execute this action.  Local actions will be performed first, then remote
+  # Execute this action. Local actions will be performed first, then remote
   # actions will be performed in parallel on each host configured for this
   # RemoteTask.
 
   def execute
-    raise Vlad::ConfigurationError, "No target hosts specified for task: #{self.name}" if target_hosts.empty?
+    raise(Vlad::ConfigurationError,
+          "No target hosts specified for task: #{self.name}") if
+      target_hosts.empty?
     super
     @remote_actions.each { |act| act.execute(target_hosts) }
   end
@@ -64,7 +147,7 @@ class Rake::RemoteTask < Rake::Task
   # Use rsync to send +local+ to +remote+ on target_host.
 
   def rsync local, remote
-    cmd = ['rsync', '-azP', '--delete', local, "#{@target_host}:#{remote}"]
+    cmd = [rsync_cmd, rsync_flags, local, "#{@target_host}:#{remote}"].flatten.compact
 
     success = system(*cmd)
 
@@ -74,81 +157,87 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # Use ssh to execute +command+ on target_host.  If +command+ uses sudo, the
+  # Use ssh to execute +command+ on target_host. If +command+ uses sudo, the
   # sudo password will be prompted for then saved for subsequent sudo commands.
 
   def run command
-    cmd = ["ssh", target_host, command]
+    cmd = [ssh_cmd, ssh_flags, target_host, command].compact
     result = []
 
-    puts cmd.join(' ') if Rake.application.options.trace
+    warn cmd.join(' ') if $TRACE
+
+    pid, inn, out, err = popen4(*cmd)
 
-    status = popen4(*cmd) do |pid, inn, out, err|
-      inn.sync = true
+    inn.sync   = true
+    streams    = [out, err]
+    out_stream = {
+      out => $stdout,
+      err => $stderr,
+    }
 
-      until out.eof? and err.eof? do
-        unless err.eof? then
-          data = err.readpartial(1024)
-          result << data
-          $stderr.write data
+    # Handle process termination ourselves
+    status = nil
+    Thread.start do
+      status = Process.waitpid2(pid).last
+    end
 
-          if data =~ /^Password:/ then
-            inn.puts sudo_password
-            result << "\n"
-            $stderr.write "\n"
-          end
+    until streams.empty? do
+      # don't busy loop
+      selected, = select streams, nil, nil, 0.1
+      next if selected.nil? or selected.empty?
+
+      selected.each do |stream|
+        if stream.eof? then
+          streams.delete stream if status # we've quit, so no more writing
+          next
         end
 
-        unless out.eof? then
-          data = out.readpartial(1024)
-          result << data
-          $stdout.write data
+        data = stream.readpartial(1024)
+        out_stream[stream].write data
+
+        if stream == err and data =~ /^Password:/ then
+          inn.puts sudo_password
+          data << "\n"
+          $stderr.write "\n"
         end
+
+        result << data
       end
     end
 
     unless status.success? then
-      raise Vlad::CommandFailedError, "execution failed with status #{status.exitstatus}: #{cmd.join ' '}"
+      raise(Vlad::CommandFailedError,
+            "execution failed with status #{status.exitstatus}: #{cmd.join ' '}")
     end
 
     result.join
   end
 
   ##
-  # Execute +command+ under sudo using run.
+  # Returns an Array with every host configured.
 
-  def sudo command
-    run "sudo #{command}"
+  def self.all_hosts
+    hosts_for(roles.keys)
   end
 
   ##
-  # The hosts this task will execute on.  The hosts are determined from the
-  # role this task belongs to.
-  #
-  # The target hosts may be overridden by providing a comma-separated list of
-  # commands to the HOSTS environment variable:
-  #
-  #   rake my_task HOSTS=app1.example.com,app2.example.com
+  # The default environment values. Used for resetting (mostly for
+  # tests).
 
-  def target_hosts
-    if hosts = ENV["HOSTS"] then
-      hosts.strip.gsub(/\s+/, '').split(",")
-    else
-      roles = options[:roles]
-      roles ? Rake::RemoteTask.hosts_for(roles) : Rake::RemoteTask.all_hosts
-    end
+  def self.default_env
+    @@default_env
   end
 
   ##
-  # Returns an Array with every host configured.
+  # The vlad environment.
 
-  def self.all_hosts
-    hosts_for(roles.keys)
+  def self.env
+    @@env
   end
 
   ##
-  # Fetches environment variable +name+ from the environment using default
-  # +default+.
+  # Fetches environment variable +name+ from the environment using
+  # default +default+.
 
   def self.fetch name, default = nil
     name = name.to_s if Symbol === name
@@ -166,8 +255,8 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # Add host +host_name+ that belongs to +roles+.  Extra arguments may be
-  # specified for the host as a hash as the last argument.
+  # Add host +host_name+ that belongs to +roles+. Extra arguments may
+  # be specified for the host as a hash as the last argument.
   #
   # host is the inversion of role:
   #
@@ -195,15 +284,32 @@ class Rake::RemoteTask < Rake::Task
     }.flatten.uniq.sort
   end
 
+  def self.mandatory name, desc # :nodoc:
+    self.set(name) do
+      raise(Vlad::ConfigurationError,
+            "Please specify the #{desc} via the #{name.inspect} variable")
+    end
+  end
+
   ##
   # Ensures exclusive access to +name+.
 
   def self.protect_env name # :nodoc:
-    @@env_locks[name.to_s].synchronize do
+    @@env_locks[name].synchronize do
       yield
     end
   end
 
+  ##
+  # Adds a remote task named +name+ with options +options+ that will
+  # execute +block+.
+
+  def self.remote_task name, options = {}, &block
+    t = Rake::RemoteTask.define_task(name, &block)
+    t.options = options
+    t
+  end
+
   ##
   # Ensures +name+ does not conflict with an existing method.
 
@@ -212,10 +318,31 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # The Rake::RemoteTask executing in this Thread.
+  # Resets vlad, restoring all roles, tasks and environment variables
+  # to the defaults.
 
-  def self.task
-    Thread.current[:task]
+  def self.reset
+    @@roles = Hash.new { |h,k| h[k] = {} }
+    @@env = {}
+    @@tasks = {}
+    @@env_locks = Hash.new { |h,k| h[k] = Mutex.new }
+
+    @@default_env.each do |k,v|
+      case v
+      when Symbol, Fixnum, nil, true, false, 42 then # ummmm... yeah. bite me.
+        @@env[k] = v
+      else
+        @@env[k] = v.dup
+      end
+    end
+  end
+
+  ##
+  # Adds role +role_name+ with +host+ and +args+ for that host.
+
+  def self.role role_name, host, args = {}
+    raise ArgumentError, "invalid host" if host.nil? or host.empty?
+    @@roles[role_name][host] = args
   end
 
   ##
@@ -228,58 +355,63 @@ class Rake::RemoteTask < Rake::Task
   end
 
   ##
-  # The configured Rake::RemoteTasks.
+  # Set environment variable +name+ to +value+ or +default_block+.
+  #
+  # If +default_block+ is defined, the block will be executed the
+  # first time the variable is fetched, and the value will be used for
+  # every subsequent fetch.
 
-  def self.tasks
-    @@tasks
-  end
+  def self.set name, value = nil, &default_block
+    raise ArgumentError, "cannot provide both a value and a block" if
+      value and default_block
+    raise ArgumentError, "cannot set reserved name: '#{name}'" if
+      Rake::RemoteTask.reserved_name?(name) unless $TESTING
 
-  ##
-  # The vlad environment.
+    Rake::RemoteTask.default_env[name.to_s] = Rake::RemoteTask.env[name.to_s] =
+      value || default_block
 
-  def self.env
-    @@env
+    Object.send :define_method, name do
+      Rake::RemoteTask.fetch name
+    end
   end
 
   ##
-  # Resets vlad, restoring all roles, tasks and environment variables to the
-  # defaults.
-
-  def self.reset
-    @@roles = Hash.new { |h,k| h[k] = {} }
-    @@env = {}
-    @@tasks = {}
-    @@env_locks = Hash.new { |h,k| h[k] = Mutex.new }
-
-    # mandatory
-    set(:application) { raise(Vlad::ConfigurationError,
-                              "Please specify the name of the application") }
-    set(:repository)  { raise(Vlad::ConfigurationError,
-                              "Please specify the repository path") }
-    set(:deploy_to)   { raise(Vlad::ConfigurationError,
-                              "Please specify the deploy path") }
-    set(:domain)      { raise(Vlad::ConfigurationError,
-                              "Please specify the server domain") }
-
-    # optional
-    set(:current_path)    { File.join(deploy_to, "current") }
-    set(:current_release) { File.join(releases_path, releases[-1]) }
-    set :keep_releases, 5
-    set :deploy_timestamped, true
-    set :deploy_via, :export
-    set(:latest_release)  { deploy_timestamped ? release_path : current_release }
-    set :migrate_args, ""
-    set :migrate_target, :latest
-    set(:previous_release){ File.join(releases_path, releases[-2]) }
-    set :rails_env, "production"
-    set :rake, "rake"
-    set(:release_name)    { Time.now.utc.strftime("%Y%m%d%H%M%S") }
-    set(:release_path)    { File.join(releases_path, release_name) }
-    set(:releases)        { task.run("ls -x #{releases_path}").split.sort }
-    set(:releases_path)   { File.join(deploy_to, "releases") }
-    set :scm, :subversion
-    set(:scm_path)        { File.join(deploy_to, "scm") }
-    set(:shared_path)     { File.join(deploy_to, "shared") }
+  # Sets all the default values. Should only be called once. Use reset
+  # if you need to restore values.
+
+  def self.set_defaults
+    @@default_env ||= {}
+    self.reset
+
+    mandatory :repository, "repository path"
+    mandatory :deploy_to,  "deploy path"
+    mandatory :domain,     "server domain"
+
+    simple_set(:deploy_timestamped, true,
+               :deploy_via,         :export,
+               :keep_releases,      5,
+               :migrate_args,       "",
+               :migrate_target,     :latest,
+               :rails_env,          "production",
+               :rake_cmd,           "rake",
+               :rsync_cmd,          "rsync",
+               :rsync_flags,        ['-azP', '--delete'],
+               :ssh_cmd,            "ssh",
+               :ssh_flags,          nil,
+               :sudo_cmd,           "sudo",
+               :sudo_flags,         nil)
+
+    set(:current_release)    { File.join(releases_path, releases[-1]) }
+    set(:latest_release)     { deploy_timestamped ?release_path: current_release }
+    set(:previous_release)   { File.join(releases_path, releases[-2]) }
+    set(:release_name)       { Time.now.utc.strftime("%Y%m%d%H%M%S") }
+    set(:release_path)       { File.join(releases_path, release_name) }
+    set(:releases)           { task.run("ls -x #{releases_path}").split.sort }
+
+    set_path :current_path,  "current"
+    set_path :releases_path, "releases"
+    set_path :scm_path,      "scm"
+    set_path :shared_path,   "shared"
 
     set(:sudo_password) do
       state = `stty -g`
@@ -297,55 +429,62 @@ class Rake::RemoteTask < Rake::Task
       end
       sudo_password
     end
+  end
 
-    set(:source) do
-      require "vlad/#{scm}"
-      Vlad.const_get(scm.to_s.capitalize).new
+  def self.set_path(name, subdir) # :nodoc:
+    set(name) { File.join(deploy_to, subdir) }
+  end
+
+  def self.simple_set(*args) # :nodoc:
+    args = Hash[*args]
+    args.each do |k, v|
+      set k, v
     end
   end
 
   ##
-  # Adds role +role_name+ with +host+ and +args+ for that host.
+  # The Rake::RemoteTask executing in this Thread.
 
-  def self.role role_name, host, args = {}
-    raise ArgumentError, "invalid host" if host.nil? or host.empty?
-    @@roles[role_name][host] = args
+  def self.task
+    Thread.current[:task]
   end
 
   ##
-  # Adds a remote task named +name+ with options +options+ that will execute
-  # +block+.
+  # The configured Rake::RemoteTasks.
 
-  def self.remote_task name, options = {}, &block
-    t = Rake::RemoteTask.define_task(name, &block)
-    t.options = options
-    roles = options[:roles]
-    t
+  def self.tasks
+    @@tasks
   end
 
   ##
-  # Set environment variable +name+ to +value+ or +default_block+.
-  #
-  # If +default_block+ is defined, the block will be executed the first time
-  # the variable is fetched, and the value will be used for every subsequent
-  # fetch.
+  # Execute +command+ under sudo using run.
 
-  def self.set name, value = nil, &default_block
-    raise ArgumentError, "cannot provide both a value and a block" if
-      value and default_block
-    raise ArgumentError, "cannot set reserved name: '#{name}'" if
-      Rake::RemoteTask.reserved_name?(name)
+  def sudo command
+    run [sudo_cmd, sudo_flags, command].compact.join(" ")
+  end
 
-    Rake::RemoteTask.env[name.to_s] = value || default_block
+  ##
+  # The hosts this task will execute on. The hosts are determined from
+  # the role this task belongs to.
+  #
+  # The target hosts may be overridden by providing a comma-separated
+  # list of commands to the HOSTS environment variable:
+  #
+  #   rake my_task HOSTS=app1.example.com,app2.example.com
 
-    Object.send :define_method, name do
-      Rake::RemoteTask.fetch name
+  def target_hosts
+    if hosts = ENV["HOSTS"] then
+      hosts.strip.gsub(/\s+/, '').split(",")
+    else
+      roles = options[:roles]
+      roles ? Rake::RemoteTask.hosts_for(roles) : Rake::RemoteTask.all_hosts
     end
   end
 
   ##
-  # Action is used to run a task's remote_actions in parallel on each of its
-  # hosts.  Actions are created automatically in Rake::RemoteTask#enhance.
+  # Action is used to run a task's remote_actions in parallel on each
+  # of its hosts. Actions are created automatically in
+  # Rake::RemoteTask#enhance.
 
   class Action
 
@@ -379,8 +518,8 @@ class Rake::RemoteTask < Rake::Task
     end
 
     ##
-    # Execute this action on +hosts+ in parallel.  Returns when block has
-    # completed for each host.
+    # Execute this action on +hosts+ in parallel. Returns when block
+    # has completed for each host.
 
     def execute hosts
       hosts.each do |host|
@@ -397,3 +536,4 @@ class Rake::RemoteTask < Rake::Task
   end
 end
 
+Rake::RemoteTask.set_defaults