yad 0.0.4

data/.gitignore

@@ -0,0 +1,9 @@
+*.sw?
+.DS_Store
+coverage
+doc/rdoc
+pkg
+*#*#
+.#*#
+.#*
+wip

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Don Barlow
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,110 @@
+= Yad: Yet Another Deployer
+
+== Description
+
+Vlad the Deployer by Ryan Davis, Eric Hodel and Wilson Bilkovich is 
+great, but it is not exactly what I wanted. The underlying 
+Rake::RemoteTask is awesome, so I wanted to keep that. However, I 
+wanted to change how the recipes work. Therefore, I created yet 
+another deployer, Yad.
+
+In general, Yad is a deployer for database-backed applications in the
+style of Capistrano by Jamis Buck. However, in addition to deploying
+Rails web applications, it can be used to deploy applications that do 
+not have a web tier and work from a cron task or something
+of that nature. 
+
+Yad works by setting up a a core set of tasks that do nothing by
+default. It is up to you to define delegates that will take the 
+actions specific for your application.
+
+http://sites.google.com/a/perrysburghacker.com/yad/_/rsrc/1247934950955/Home/yad.png
+
+At this time, the following delegates are supported:
+
+==== Source Code Managers
+* Git
+==== Database Managers
+* None
+* Rails
+==== Frameworks
+* None
+* Rails
+==== Application Servers
+* Passenger
+==== Maintenance Page  
+* Shared System 
+  (i.e. maintenance.html in the shared/config directory copied to the shared/system 
+  directory to be seen by your web server)
+==== Web Servers
+* Apache
+
+
+== Installation
+
+  sudo gem install yad
+or
+  sudo gem install ottobar-yad
+
+
+== Examples
+
+=== Single stage with git, rails and passenger
+
+* Create a deploy.rake file:
+
+    # #{Rails.root}/lib/tasks/deploy.rake
+    begin
+      require 'yad'
+
+      set :application, "myapp"
+      set :repository, "path/to/my/repository/#{application}.git"
+      set :domain, "mydomain.com"
+      set :deploy_to "/home/deploy/projects/#{application}"
+
+      set :scm, :git
+      set :framework, :rails
+      # assumes that you have a config/database_production.yml file in your repository
+      set :framework_update_db_config_via, :copy
+      set :db, :rails
+      set :app, :passenger
+
+      desc "Deploy a new version of the application"
+      task "yad:deploy" => %w(yad:update yad:start_app yad:cleanup)
+
+      desc "Deploy a new version of the application and run database migrations"
+      task "yad:deploy_with_migrations" => %w(yad:update yad:migrate_db yad:start_app yad:cleanup)
+
+    rescue LoadError
+      puts "Yad not available. Install it with: sudo gem install yad"
+    end
+
+* For initial deployment, run the following tasks:
+
+    rake yad:setup
+    rake yad:update
+    rake yad:create_db
+    rake yad:migrate_db
+
+* Then, configure or otherwise set up your web server
+
+* For subsequent releases, run:
+
+    rake yad:deploy
+    or
+    rake yad:deploy_with_migrations
+
+--
+see the FAQ[link:files/doc/faq_rdoc.html] for more details
+++
+
+== Links
+
+* http://github.com/ottobar/yad/tree/master
+* http://yad.rubyforge.org
+* http://rubyforge.org/projects/yad
+
+
+== Copyright
+
+Copyright (c) 2009 Don Barlow. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "yad"
+    gem.description = "Yad: Yet Another Deployer"
+    gem.summary = %Q{Yet another deployer, pretty much stolen from Vlad}
+    gem.email = "ottobar@perryburghacker.com"
+    gem.homepage = "http://yad.rubyforge.org"
+    gem.authors = ["Don Barlow"]
+    gem.rubyforge_project = "yad"
+    gem.add_dependency('rake', '~> 0.8.7')
+    gem.add_dependency('open4', '~> 0.9.6')
+    gem.add_development_dependency('voloko-sdoc', '~> 0.2.12.1')
+    gem.add_development_dependency('technicalpickles-jeweler', '~> 1.0.1')
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+begin
+  require 'sdoc'
+  Rake::RDocTask.new('doc') do |rdoc|
+    if File.exist?('VERSION.yml')
+      config = YAML.load(File.read('VERSION.yml'))
+      version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+    else
+      version = ""
+    end
+
+    rdoc.rdoc_dir = 'doc/rdoc'
+    rdoc.title = "Yad: Yet Another Deployer v#{version}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.rdoc_files.include('LICENSE')
+    rdoc.rdoc_files.include('doc/faq.rdoc')
+    rdoc.main = 'README.rdoc'
+    rdoc.template = 'direct'
+  end
+rescue LoadError
+  puts "Sdoc not available. Install it with: sudo gem install voloko-sdoc -s http://gems.github.com"
+end
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+    
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+    
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:doc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/yad/"
+        local_dir = 'doc/rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 4

data/doc/faq.rdoc

@@ -0,0 +1,9 @@
+= Title here
+
+and a paragraph here
+and then such
+
+== something else
+
+ * one thing
+ * thing 2

data/features/support/env.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'yad'
+
+require 'spec/expectations'
+
+World do |world|
+  
+  world
+end

data/features/yad.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/lib/ext/rake.rb

@@ -0,0 +1,66 @@
+module Rake
+  module TaskManager
+    # This gives us access to the tasks already defined in rake.
+    def all_tasks
+      @tasks
+    end
+  end
+
+  # Simple shortcut for Rake.application.all_tasks
+  def self.all_tasks
+    Rake.application.all_tasks
+  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
+        all_tasks.delete_if { |k,_| k =~ name }
+      else
+        all_tasks.delete(name)
+      end
+    end
+  end
+
+  # Removes the last action added to a task. Use this when two
+  # libraries define the same task and you only want one of the
+  # actions.
+  #
+  #   require 'hoe'
+  #   require 'tasks/rails'
+  #   Rake.undo("test") # rolls out rails' test task
+  def self.undo(*names)
+    names.each do |name|
+      all_tasks[name].actions.delete_at(-1)
+    end
+  end
+  
+  class Task
+    # Invokes the task named +task_name+ if the +module_name+ has been
+    # defined. It is the mechanism for delegating commands out of the
+    # core to modules specific for your application
+    def self.invoke_if_defined(task_name, module_name, error_message = nil)
+      module_value = Rake::RemoteTask.fetch(module_name, false)
+      if module_value
+        # define delegated tasks
+        eval("Yad::#{module_name.to_s.classify}::#{module_value.to_s.classify}.define_tasks")
+        Rake::Task[task_name].invoke
+      elsif error_message
+        raise ArgumentError, error_message
+      end
+    end
+  end
+end
+
+if Gem::Version.new(RAKEVERSION) < Gem::Version.new('0.8') then
+  class Rake::Task
+    alias task_original_execute execute
+
+    def execute(args = nil)
+      task_original_execute
+    end
+  end
+end

data/lib/ext/rake/remote_task.rb

@@ -0,0 +1,521 @@
+$TESTING ||= false
+$TRACE = Rake.application.options.trace
+$-w = true if $TRACE
+
+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
+  # Base error class for all  errors.
+  class Error < RuntimeError; end
+
+  # Raised when you have incorrect configuration.
+  class ConfigurationError < Error; end
+
+  # Raised when a remote command fails.
+  class CommandFailedError < Error; end
+
+  # Raised when an environment variable hasn't been set.
+  class FetchError < Error; end
+  
+  @@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 = []
+  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(Rake::RemoteTask::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
+  
+  # Pulls +files+ from the +target_host+ using rsync to +local_directory+.
+  def get(local_directory, *files)
+    rsync(files.map { |f| "#{target_host}:#{f}" }, local_directory)
+  end
+  
+  # Copys 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
+      rsync(fp.path, "#{target_host}:#{remote_path}")
+    end
+  end
+  
+  # Use rsync to send +local+ to +remote+.
+  def rsync(local, remote)
+    cmd = [rsync_cmd, rsync_flags, local, remote].flatten.compact
+    cmdstr = cmd.join(' ')
+
+    warn cmdstr if $TRACE
+
+    success = system(*cmd)
+
+    unless success then
+      raise Rake::RemoteTask::CommandFailedError, "execution failed: #{cmdstr}"
+    end
+  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(Rake::RemoteTask::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 remote task 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 Rake::RemoteTask::FetchError
+    end
+  end
+  
+  # Fetches a set of options and turns it into a hash to be passed to
+  # the application specific delegate tasks.
+  def self.get_options_hash(*options)
+    options_hash = {}
+    options.each do |option|
+      option_value = Rake::RemoteTask.fetch(option, false)
+      options_hash[option] = option_value if option_value
+    end
+    options_hash
+  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(Rake::RemoteTask::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.
+        @@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 = 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(:app_env,            "production",
+               :deploy_timestamped, true,
+               :keep_releases,      5,
+               :rake_cmd,           "rake",
+               :rsync_cmd,          "rsync",
+               :rsync_flags,        ['-azP', '--delete'],
+               :ssh_cmd,            "ssh",
+               :ssh_flags,          [],
+               :sudo_cmd,           "sudo",
+               :sudo_flags,         ['-p Password:'],
+               :sudo_prompt,        /^Password:/)   
+    
+    set(:latest_release)     { deploy_timestamped ? File.join(releases_path, releases[-1]) : releases_path }
+    set(:previous_release) do
+      if deploy_timestamped
+        if releases[-2]
+          File.join(releases_path, releases[-2])
+        else
+          nil
+        end
+      else
+        releases_path
+      end
+    end
+    set(:release_name)       { deploy_timestamped ? Time.now.utc.strftime("%Y%m%d%H%M%S") : nil }
+    set(:release_path)       { release_name ? File.join(releases_path, release_name) : releases_path }
+    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_path :shared_config_path,  File.join("shared", "config")
+    
+    set(:sudo_password) do
+      state = `stty -g`
+
+      raise Rake::RemoteTask::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.abort_on_exception = true
+          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