lastobelus-vlad 1.4.0

data/doco/deploying-sinatra-with-vlad.txt

@@ -0,0 +1,119 @@
+# Deploying Sinatra with Vlad
+
+This tutorial has been adapted from [Deploying Sinatra with Vlad](http://effectif.com/articles/deploying-sinatra-with-vlad) by [Graham Ashton](http://effectif.com "Effectif Development").
+
+So you've just written a nice new [Sinatra application](http://www.sinatrarb.com/ "Sinatra"), and you want to get it running on your web server. How hard can it be? Well with [Vlad the Deployer](http://rubyhitsquad.com/Vlad_the_Deployer.html "Vlad the Deployer"), it's actually rather easy.
+
+## Creating a sample application
+
+Let's start by making ourselves a test app:
+
+    $ mkdir hello
+    $ cd hello
+    $ touch app.rb
+
+Open `app.rb` in your editor and put this code in it:
+
+    require "rubygems"
+    require "sinatra"
+
+    get "/" do
+      "Hello!"
+    end
+
+We can check that the app works locally by running it...
+
+    $ ruby app.rb
+
+...and then opening [http://localhost:4567](http://localhost:4567) in a web browser.
+
+We need to create a `public` directory too, as Vlad assumes that we have a `public` directory for our static assets. I'm also going to make an empty CSS file so that the directory doesn't get ignored by Git:
+
+    $ mkdir public
+    $ touch public/master.css
+
+We'll deploy our application from version control. I'm using Git, but you can use any system that Vlad supports; just check your files into a repository that will be accessible from your web server.
+
+## Configuring Vlad
+
+Okay, we're ready for Vlad. It's a Ruby gem, so it's very easy to install:
+
+    $ sudo gem install vlad
+    Successfully installed vlad-1.2.0
+    1 gem installed
+    Installing ri documentation for vlad-1.2.0...
+    Installing RDoc documentation for vlad-1.2.0...
+
+There's no need to install Vlad on your server, just your workstation.
+
+You access Vlad's functionality through Rake tasks. This means that we need a `Rakefile` which loads the Vlad code. Create `Rakefile` in the same directory as `app.rb`, then add the following code to it:
+
+    begin
+      require "vlad"
+      Vlad.load(:app => nil, :scm => "git")
+    rescue LoadError
+      # do nothing
+    end
+
+Note that we've told Vlad that we intend to use Git (subversion is the default). We've set `:app` to `nil` as Vlad assumes that we'll run our application with [Mongrel](http://mongrel.rubyforge.org/ "Mongrel - Trac"). I'm not going to use Mongrel here, so we don't want Vlad to load its Mongrel recipes.
+
+If you run `rake -T` now you should see a bunch of vlad tasks that are available to you. You can't run them yet; you need to configure Vlad with a `config/deploy.rb` file:
+
+    $ mkdir config
+    $ touch config/deploy.rb
+
+Open `deploy.rb` in your editor and set the following variables:
+
+    set :application, "hello"
+    set :repository, "ssh://your.git.server/path/to/project/hello.git"
+    set :domain, "your.web.server"
+    set :deploy_to, "/var/apps/#{application}"
+
+Make sure that `:repository` correctly references your source control system, and that `:domain` is set to the hostname of your server.
+
+I won't be able to create any directories under the `/var/apps` directory (I'm going to run vlad using my own username in this example), so I need to login to my server and make sure that I can create files in the `hello` directory:
+
+    $ ssh your.web.server
+    $ sudo mkdir -p /var/apps/hello
+    $ sudo chown yourusername /var/apps/hello
+
+Now you can try running Vlad, to create all the directories necessary to serve your project. Back on your workstation, type:
+
+    $ rake vlad:setup
+
+You should find that some directories have been created within `/var/apps/hello` on your server.
+
+Let's trying deploying some code:
+
+    $ rake vlad:update
+    (in /Users/graham/data/effectif/projects/hello)
+    Initialized empty Git repository in /var/apps/hello/scm/repo/.git/
+    Switched to a new branch "deployed-HEAD"
+
+You should now find that if you ssh into your server that you can run the application:
+
+    $ ssh your.web.server
+    $ cd /var/apps/hello/current
+    $ ruby app.rb
+
+Try making a change to your source, committing it to your repository, then run `vlad:update` again. Your code will be updated. If you restart Sinatra in the new directory you'll see your changes in the browser.
+
+If you're following along with these commands, be careful that you're running `app.rb` in the freshly deployed directory. `current` is a symlink to a specific release directory, so you'll need to leave the directory and return to it to see the new source code (i.e. symlinks don't get updated under your shell's feet). This should do it:
+
+    $ cd ~ && cd -
+    $ ruby app.rb
+
+You may now be wondering how to get Thin running automatically, and how to re-start it when you run `vlad:update`. That should be the subject of my next blog post (you can [subscribe](/articles.xml) if you need it).
+
+## Deploying from a Git branch
+
+If you want to deploy from a specific Git branch (`master` is the default) you can set the `:revision` variable in `deploy.rb`:
+
+    set :revision, "origin/mybranch"
+
+## Deploying as a different user
+
+It's not a great idea to deploy and run applications as your own login name (it's better practice to run web applications as users that don't have many privileges). I've not really addressed users in this article in order to focus on the basics of Vlad, but if you're interested you can deploy as a different user with these settings in `deploy.rb`:
+
+    set :user, "deploy"
+    set :domain, "#{user}@domain.com"

data/doco/faq.txt

@@ -0,0 +1,131 @@
+== 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 is there no vlad:deploy?
+=== A: Because everyone is a unique beautiful flower.
+
+Everyone's deployment is different. Everyone. Unique scaling
+requirements. Yadda yadda yadda. So rather than supply something that
+nobody will use, we decided not to supply anything at all. Here is an
+example deploy that I stole from the web (and improved) that you may like:
+
+    desc "Full deployment cycle"
+    task "vlad:deploy" => %w[
+      vlad:update
+      vlad:migrate
+      vlad:reset_session
+      vlad:start
+      vlad:cleanup
+    ]
+
+Just pop that in your config/deploy.rb, tweak it as necessary, and have at it.
+
+=== 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 can I replace a rake task instead of just adding to it?
+=== A: Use Rake.clear_tasks str_or_regexp
+
+  namespace :vlad do
+    # Clear existing update task so that we can redefine instead of adding to it.
+    Rake.clear_tasks('vlad:update') 
+  
+    remote_task :update, :roles => :app do
+      #custom update stuff
+    end
+  end
+
+=== 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 (on tiger, not leopard), use SSHKeychain, we love it. <http://www.sshkeychain.org/>. If you are on leopard, you get all of this for free.
+
+=== Q: How do I use Vlad with a gateway?
+=== A: Add the following to your deploy.rb variables:
+
+  set :ssh_flags, "-A #{mygateway}"
+  set :rsync_flags, "--rsh ssh -A #{mygateway} ssh"
+
+=== Q: OMG subversion is stupid! It keeps asking for "Authentication Realm"
+=== A: Yes, yes it is.
+
+If you're seeing local checkouts work fine but they don't over ssh
+(even to localhost!) then ssh into that machine (yes, even localhost)
+and do a checkout there to a temporary directory. From then on,
+checkout over ssh should work fine.
+
+  % svn co https://blah/blah /tmp/happy
+    ... works fine ...
+  % ssh localhost svn co https://blah/blah /tmp/sad
+    ... asks for authentication and then hangs ...
+  % ssh localhost
+  % svn co https://blah/blah /tmp/sad-no-happy
+    ... asks for authentication ...
+    ... works fine ...
+  % ssh localhost svn co https://blah/blah /tmp/happy2
+    ... works fine ...

data/doco/getting_started.txt

@@ -0,0 +1,61 @@
+
+== Quick Start for a 1-Server Solution:
+
+=== Setup
+
+* Create a deploy file, usually in "config/deploy.rb":
+
+    set :application, "project"
+    set :domain, "example.com"
+    set :deploy_to, "/path/to/install"
+    set :repository, 'http://svn.example.com/project/branches/stable/'
+    
+This defaults to using 'svn export' from +repository+, and a single
+server for +app+, +db+, and +www+. If you need to tweak these things,
+refer to the variable documentation.
+
+* If you want a multi-config environment, change your config like so:
+
+    set :application, "project"
+    set :repository, 'http://svn.example.com/project/branches/stable/'
+    
+    task :beta do
+      set :domain,    "beta.example.com"
+      set :deploy_to, "/path/to/install-beta"
+    end
+    
+    task :dev do
+      set :domain,    "dev.example.com"
+      set :deploy_to, "/path/to/install-dev"
+    end
+    
+    task :prod do
+      set :domain,    "example.com"
+      set :deploy_to, "/path/to/install"
+    end
+
+* Add the following to your Rakefile:
+
+    begin
+      require 'vlad'
+      Vlad.load
+    rescue LoadError
+      # do nothing
+    end
+
+Vlad.load has a lot of flexibility. See the rdoc for full information.
+
+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

@@ -0,0 +1,43 @@
+== 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
+* Uses real ssh so env vars and the like are not a problem
+  - no +with_env+ as a result.
+* Vlad doesn't use ':no_release' or ':primary'.
+  - If you have a task that needs to run on only one host from a role,
+    you should declare a new role for that host:
+
+      role :master_db, "master.example.com"
+
+    ..and then override the role for the task you want to limit:
+
+      Rake::Task["mytask"].options[:roles] = :master_db
+
+* The 'host' method can be used to consolidate multiple 'role' calls.
+  - 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/perforce.txt

@@ -0,0 +1,5 @@
+# Using Perforce
+
+TODO: write real doco.
+
+Set up a .p4config file and put it in the client's scm directories.

data/doco/variables.txt

@@ -0,0 +1,79 @@
+
+== Core Variables
+
+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
+                       server. e.g. example.com
+current_path::         The full path on the remote host that will be symlinked
+                       as 'current'. Defaults to "#{deploy_to}/current".
+current_release::      The full path to the current release's actual location.
+                       Defaults to "#{releases_path}/#{releases.last}".
+deploy_timestamped::   Create timestamped release directories instead of using
+                       revision numbers. Defaults to true.
+deploy_via::           Which SCM command should be used when deploying the app.
+                       Defaults to "export".
+latest_release::       The most recent release, which may not yet have been
+                       symlinked. Defaults to release_path.
+migrate_args::         Set this to change the RAILS_ENV that 'rake db:migrate'
+                       will run under. Defaults to "".
+migrate_target::       Set this if you need to specify a particular migration
+                       'VERSION' number. Defaults to "latest".
+rails_env::            Specifies the RAILS_ENV environment variable that will
+                       be used. Defaults to "production".
+rake_cmd::             Set this if you need to specify an alternate path to
+                       'rake'. Defaults to "rake".
+release_name::         Name of the release directory, if deploy_timestamped is
+                       true. Defaults to timestamp: "YYYYMMDDHHMMSS".
+release_path::         Path to this release, which may not have been created
+                       yet. Defaults to "#{releases_path}/#{release_name}".
+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".
+revision::             Revision to use for release. Defaults to 'head'.
+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".
+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 ["-p Password:"].
+sudo_prompt::          Regexp for sudo password prompt. Defaults to /^Password:/.
+sudo_password::        Asks for password when referenced.
+umask::                Sets your umask value. Defaults to "02".
+
+== 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

@@ -0,0 +1,589 @@
+require 'rubygems'
+require 'open4'
+require 'rake'
+require 'vlad'
+
+$TESTING ||= false
+$TRACE = Rake.application.options.trace
+$-w = true if $TRACE # asshat, don't mess with my warn.
+
+def export receiver, *methods
+  methods.each do |method|
+    eval "def #{method} *args, █ #{receiver}.#{method}(*args, &block);end"
+  end
+end
+
+export "Thread.current[:task]", :get, :put, :rsync, :run, :sudo, :target_host
+export "Rake::RemoteTask",      :host, :remote_task, :role, :set
+
+##
+# 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
+
+  @@current_roles = []
+
+  include Open4
+
+  ##
+  # Options for execution of this task.
+
+  attr_accessor :options
+
+  ##
+  # The host this task is running on during execution.
+
+  attr_accessor :target_host
+
+  ##
+  # An Array of Actions this host will perform during execution. Use
+  # enhance to add new actions to a task.
+
+  attr_reader :remote_actions
+
+  def self.current_roles
+    @@current_roles
+  end
+
+  ##
+  # Create a new task named +task_name+ attached to Rake::Application +app+.
+
+  def initialize(task_name, app)
+    super
+
+    @remote_actions = []
+    @happy = false # used for deprecation warnings on get/put/rsync
+  end
+
+  ##
+  # 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
+  # Rake::Task#enhance.
+
+  def enhance(deps=nil, &block)
+    original_enhance(deps) # can't use super because block passed regardless.
+    @remote_actions << Action.new(self, block) if block_given?
+    self
+  end
+
+  ##
+  # 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(args = nil)
+    raise(Vlad::ConfigurationError,
+          "No target hosts specified on task #{self.name} for roles #{options[:roles].inspect}") if
+      ! defined_target_hosts?
+
+    super args
+
+    @remote_actions.each { |act| act.execute(target_hosts, self, args) }
+  end
+
+  ##
+  # Pull +files+ from the remote +host+ using rsync to +local_dir+.
+  # TODO: what if role has multiple hosts & the files overlap? subdirs?
+
+  def get local_dir, *files
+    @happy = true
+    host = target_host
+    rsync files.map { |f| "#{host}:#{f}" }, local_dir
+    @happy = false
+  end
+
+  ##
+  # Copy a (usually generated) file to +remote_path+. Contents of block
+  # are copied to +remote_path+ and you may specify an optional
+  # base_name for the tempfile (aids in debugging).
+
+  def put remote_path, base_name = File.basename(remote_path)
+    require 'tempfile'
+    Tempfile.open base_name do |fp|
+      fp.puts yield
+      fp.flush
+      @happy = true
+      rsync fp.path, "#{target_host}:#{remote_path}"
+      @happy = false
+    end
+  end
+
+  ##
+  # Execute rsync with +args+. Tacks on pre-specified +rsync_cmd+ and
+  # +rsync_flags+.
+  #
+  # Favor #get and #put for most tasks. Old-style direct use where the
+  # target_host was implicit is now deprecated.
+
+  def rsync *args
+    unless @happy || args[-1] =~ /:/ then
+      warn "rsync deprecation: pass target_host:remote_path explicitly"
+      args[-1] = "#{target_host}:#{args[-1]}"
+    end
+
+    cmd    = [rsync_cmd, rsync_flags, args].flatten.compact
+    cmdstr = cmd.join ' '
+
+    warn cmdstr if $TRACE
+
+    success = system(*cmd)
+
+    raise Vlad::CommandFailedError, "execution failed: #{cmdstr}" unless success
+  end
+
+  ##
+  # 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_cmd, ssh_flags, target_host, command].flatten
+    result = []
+
+    trace = [ssh_cmd, ssh_flags, target_host, "'#{command}'"].flatten.join(' ')
+    warn trace if $TRACE
+
+    pid, inn, out, err = popen4(*cmd)
+
+    inn.sync   = true
+    streams    = [out, err]
+    out_stream = {
+      out => $stdout,
+      err => $stderr,
+    }
+
+    # Handle process termination ourselves
+    status = nil
+    Thread.start do
+      status = Process.waitpid2(pid).last
+    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
+
+        data = stream.readpartial(1024)
+        out_stream[stream].write data
+
+        if stream == err and data =~ sudo_prompt 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 ' '}")
+    end
+
+    result.join
+  ensure
+    inn.close rescue nil
+    out.close rescue nil
+    err.close rescue nil
+  end
+
+  ##
+  # Returns an Array with every host configured.
+
+  def self.all_hosts
+    hosts_for(roles.keys)
+  end
+
+  ##
+  # The default environment values. Used for resetting (mostly for
+  # tests).
+
+  def self.default_env
+    @@default_env
+  end
+
+  def self.per_thread
+    @@per_thread
+  end
+
+  ##
+  # The vlad environment.
+
+  def self.env
+    @@env
+  end
+
+  ##
+  # Fetches environment variable +name+ from the environment using
+  # default +default+.
+
+  def self.fetch name, default = nil
+    name = name.to_s if Symbol === name
+    if @@env.has_key? name then
+      protect_env(name) do
+        v = @@env[name]
+        v = @@env[name] = v.call if Proc === v unless per_thread[name]
+        v = v.call if Proc === v
+        v
+      end
+    elsif default || default == false
+      v = @@env[name] = default
+    else
+      raise Vlad::FetchError
+    end
+  end
+
+  ##
+  # 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:
+  #
+  #   host 'db1.example.com', :db, :master_db
+  #
+  # Is equivalent to:
+  #
+  #   role :db, 'db1.example.com'
+  #   role :master_db, 'db1.example.com'
+
+  def self.host host_name, *roles
+    opts = Hash === roles.last ? roles.pop : {}
+
+    roles.each do |role_name|
+      role role_name, host_name, opts.dup
+    end
+  end
+
+  ##
+  # Returns an Array of all hosts in +roles+.
+
+  def self.hosts_for *roles
+    roles.flatten.map { |r|
+      self.roles[r].keys
+    }.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].synchronize do
+      yield
+    end
+  end
+
+  ##
+  # Adds a remote task named +name+ with options +options+ that will
+  # execute +block+.
+
+  def self.remote_task name, *args, &block
+    options = (Hash === args.last) ? args.pop : {}
+    t = Rake::RemoteTask.define_task(name, *args, &block)
+    options[:roles] = Array options[:roles]
+    options[:roles] |= @@current_roles
+    t.options = options
+    t
+  end
+
+  ##
+  # Ensures +name+ does not conflict with an existing method.
+
+  def self.reserved_name? name # :nodoc:
+    !@@env.has_key?(name.to_s) && self.respond_to?(name)
+  end
+
+  ##
+  # Resets vlad, restoring all roles, tasks and environment variables
+  # to the defaults.
+
+  def self.reset
+    @@def_role_hash = {}                # official default role value
+    @@env           = {}
+    @@tasks         = {}
+    @@roles         = Hash.new { |h,k| h[k] = @@def_role_hash }
+    @@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.
+  # TODO: merge:
+  # Declare a role and assign a remote host to it. Equivalent to the
+  # <tt>host</tt> method; provided for capistrano compatibility.
+
+  def self.role role_name, host = nil, args = {}
+    if block_given? then
+      raise ArgumentError, 'host not allowed with block' unless host.nil?
+
+      begin
+        current_roles << role_name
+        yield
+      ensure
+        current_roles.delete role_name
+      end
+    else
+      raise ArgumentError, 'host required' if host.nil?
+
+      [*host].each do |hst|
+        raise ArgumentError, "invalid host: #{hst}" if hst.nil? or hst.empty?
+      end
+      @@roles[role_name] = {} if @@def_role_hash.eql? @@roles[role_name]
+      @@roles[role_name][host] = args
+    end
+  end
+
+  ##
+  # The configured roles.
+
+  def self.roles
+    host domain, :app, :web, :db if @@roles.empty?
+
+    @@roles
+  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.
+
+  def self.set name, value = nil, &default_block
+    raise ArgumentError, "cannot provide both a value and a block" if
+      value and default_block unless
+      value == :per_thread
+    raise ArgumentError, "cannot set reserved name: '#{name}'" if
+      Rake::RemoteTask.reserved_name?(name) unless $TESTING
+
+    name = name.to_s
+
+    Rake::RemoteTask.per_thread[name] = true if
+      default_block && value == :per_thread
+
+    Rake::RemoteTask.default_env[name] = Rake::RemoteTask.env[name] =
+      default_block || value
+
+    Object.send :define_method, name do
+      Rake::RemoteTask.fetch name
+    end
+  end
+
+  ##
+  # Sets all the default values. Should only be called once. Use reset
+  # if you need to restore values.
+
+  def self.set_defaults
+    @@default_env ||= {}
+    @@per_thread  ||= {}
+    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",
+               :revision,           "head",
+               :rsync_cmd,          "rsync",
+               :rsync_flags,        ['-azP', '--delete'],
+               :ssh_cmd,            "ssh",
+               :ssh_flags,          [],
+               :sudo_cmd,           "sudo",
+               :sudo_flags,         ['-p Password:'],
+               :sudo_prompt,        /^Password:/,
+               :umask,              '02')
+
+    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`
+
+      raise Vlad::Error, "stty(1) not found" unless $?.success?
+
+      begin
+        system "stty -echo"
+        $stdout.print "sudo password: "
+        $stdout.flush
+        sudo_password = $stdin.gets
+        $stdout.puts
+      ensure
+        system "stty #{state}"
+      end
+      sudo_password
+    end
+  end
+
+  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
+
+  ##
+  # The Rake::RemoteTask executing in this Thread.
+
+  def self.task
+    Thread.current[:task]
+  end
+
+  ##
+  # The configured Rake::RemoteTasks.
+
+  def self.tasks
+    @@tasks
+  end
+
+  ##
+  # Execute +command+ under sudo using run.
+
+  def sudo command
+    run [sudo_cmd, sudo_flags, command].flatten.compact.join(" ")
+  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
+
+  def target_hosts
+    if hosts = ENV["HOSTS"] then
+      hosts.strip.gsub(/\s+/, '').split(",")
+    else
+      roles = Array options[:roles]
+
+      if roles.empty? then
+        Rake::RemoteTask.all_hosts
+      else
+        Rake::RemoteTask.hosts_for roles
+      end
+    end
+  end
+
+  ##
+  # Similar to target_hosts, but returns true if user defined any hosts, even
+  # an empty list.
+
+  def defined_target_hosts?
+    return true if ENV["HOSTS"]
+    roles = Array options[:roles]
+    return true if roles.empty?
+    # borrowed from hosts_for:
+    roles.flatten.each { |r|
+      return true unless @@def_role_hash.eql? Rake::RemoteTask.roles[r] 
+    }
+    return false
+  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.
+
+  class Action
+
+    ##
+    # The task this action is attached to.
+
+    attr_reader :task
+
+    ##
+    # The block this action will execute.
+
+    attr_reader :block
+
+    ##
+    # An Array of threads, one for each host this action executes on.
+
+    attr_reader :workers
+
+    ##
+    # Creates a new Action that will run +block+ for +task+.
+
+    def initialize task, block
+      @task  = task
+      @block = block
+      @workers = ThreadGroup.new
+    end
+
+    def == other # :nodoc:
+      return false unless Action === other
+      block == other.block && task == other.task
+    end
+
+    ##
+    # Execute this action on +hosts+ in parallel. Returns when block
+    # has completed for each host.
+
+    def execute hosts, task, args
+      hosts.each do |host|
+        t = task.clone
+        t.target_host = host
+        thread = Thread.new(t) do |task|
+          Thread.current[:task] = task
+          case block.arity
+          when 1
+            block.call task
+          else
+            block.call task, args
+          end
+          Thread.current[:task] = nil
+        end
+        @workers.add thread
+      end
+      @workers.list.each { |thr| thr.join }
+    end
+  end
+end
+
+Rake::RemoteTask.set_defaults