wesabe-robot-army 0.1.1 → 0.1.7

data/examples/whoami.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'robot-army')
+
+class Whoami < RobotArmy::TaskMaster
+  desc 'test', "Tests whoami"
+  method_options :root => :boolean, :host => :string
+  def test(options={})
+    self.host = options['host']
+    puts options['root'] ?
+      sudo{ `whoami` } :
+      remote{ `whoami` }
+  end
+end

data/lib/robot-army.rb

@@ -2,29 +2,35 @@ require 'rubygems'
 require 'open3'
 require 'base64'
 require 'thor'
-gem 'ruby2ruby', '=1.1.9'
+
+gem 'ParseTree', '>=3'
+require 'parse_tree'
+
+gem 'ruby2ruby', '>=1.2.0'
 require 'ruby2ruby'
+require 'parse_tree_extensions'
+
 require 'fileutils'
 
 module RobotArmy
   # Gets the upstream messenger.
-  # 
+  #
   # @return [RobotArmy::Messenger]
   #   A messenger connection pointing upstream.
-  # 
+  #
   def self.upstream
     @upstream
   end
-  
+
   # Sets the upstream messenger.
-  # 
+  #
   # @param messenger [RobotArmy::Messenger]
   #   A messenger connection pointing upstream.
-  # 
+  #
   def self.upstream=(messenger)
     @upstream = messenger
   end
-  
+
   class ConnectionNotOpen < StandardError; end
   class Warning < StandardError; end
   class HostArityError < StandardError; end
@@ -35,41 +41,61 @@ module RobotArmy
   end
   class RobotArmy::Exit < Exception
     attr_accessor :status
-    
+
     def initialize(status=0)
       @status = status
     end
   end
-  
+
   CHARACTERS = %w[a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9]
-  
+
   # Generates a random string of lowercase letters and numbers.
-  # 
+  #
   # @param length [Fixnum]
   #   The length of the string to generate.
-  # 
+  #
   # @return [String]
   #   The random string.
-  # 
+  #
   def self.random_string(length=16)
     (0...length).map{ CHARACTERS[rand(CHARACTERS.size)] }.join
   end
-end
 
-%w[loader dependency_loader io 
-   officer_loader soldier officer 
-   messenger task_master proxy 
-   connection officer_connection 
-   marshal_ext gate_keeper ruby2ruby_ext].each do |file|
-  require File.join(File.dirname(__FILE__), 'robot-army', file)
+  def self.ask_for_password(host, data={})
+    require 'highline'
+    HighLine.new.ask("[sudo] password for #{data[:user]}@#{host}: ") {|q| q.echo = false}
+  end
 end
 
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'robot-army/loader'
+require 'robot-army/dependency_loader'
+require 'robot-army/io'
+require 'robot-army/officer_loader'
+require 'robot-army/soldier'
+require 'robot-army/officer'
+require 'robot-army/messenger'
+require 'robot-army/task_master'
+require 'robot-army/proxy'
+require 'robot-army/eval_builder'
+require 'robot-army/eval_command'
+require 'robot-army/remote_evaler'
+require 'robot-army/keychain'
+require 'robot-army/connection'
+require 'robot-army/officer_connection'
+require 'robot-army/marshal_ext'
+require 'robot-army/gate_keeper'
+require 'robot-army/at_exit'
+require 'robot-army/ruby2ruby_ext'
+
 at_exit do
+  RobotArmy::AtExit.shared_instance.do_exit
   RobotArmy::GateKeeper.shared_instance.close
 end
 
 def debug(*whatever)
   File.open('/tmp/robot-army.log', 'a') do |f|
     f.puts "[#{Process.pid}] #{whatever.join(' ')}"
-  end if $TESTING
+  end if $TESTING || $ROBOT_ARMY_DEBUG
 end

data/lib/robot-army/at_exit.rb

@@ -0,0 +1,19 @@
+class RobotArmy::AtExit
+  def at_exit(&block)
+    callbacks << block
+  end
+
+  def do_exit
+    callbacks.pop.call while callbacks.last
+  end
+
+  def self.shared_instance
+    @shared_instance ||= new
+  end
+
+  private
+
+  def callbacks
+    @callbacks ||= []
+  end
+end

data/lib/robot-army/eval_builder.rb

@@ -0,0 +1,84 @@
+class RobotArmy::EvalBuilder
+  def self.build(command)
+    new.build(command)
+  end
+
+  def build(command)
+    proc, procargs, context, dependencies =
+      command.proc, command.args, command.context, command.dependencies
+
+    options = {}
+    proxies = {context.hash => context}
+
+    # fix stack traces
+    file, line = eval('[__FILE__, __LINE__]', proc.binding)
+
+    # include local variables
+    local_variables = eval('local_variables', proc.binding)
+    locals, lproxies = dump_values(local_variables) { |name,| eval(name, proc.binding) }
+    proxies.merge! lproxies
+
+    # include arguments
+    args, aproxies = dump_values(proc.arguments) { |_, i| procargs[i] }
+    proxies.merge! aproxies
+
+    # include dependency loader
+    dep_loading = "Marshal.load(#{Marshal.dump(dependencies).inspect}).load!"
+
+    # get the code for the proc
+    proc = "proc{ #{proc.to_ruby_without_proc_wrapper} }"
+    messenger = "RobotArmy::Messenger.new($stdin, $stdout)"
+    context = "RobotArmy::Proxy.new(#{messenger}, #{context.hash.inspect})"
+
+    code = %{
+      #{dep_loading} # load dependencies
+      #{(locals+args).join("\n")} # all local variables
+      #{context}.__proxy_instance_eval(&#{proc}) # run the block
+    }
+
+    options[:file] = file
+    options[:line] = line
+    options[:code] = code
+    options[:user] = command.user if command.user
+
+    return options, proxies
+  end
+
+  private
+
+  # Dumps the values associated with the given names for transport.
+  #
+  # @param names [Array[String]]
+  #   The names of the variables to dump.
+  #
+  # @yield [name, index]
+  #   Yields the name and its index and expects
+  #   to get the corresponding value.
+  #
+  # @yieldparam [String] name
+  #   The name of the value for the block to return.
+  #
+  # @yieldparam [Fixnum] index
+  #   The index of the value for the block to return.
+  #
+  # @return [(Array[Object], Hash[Fixnum => Object])]
+  #   The pair +values+ and +proxies+.
+  #
+  def dump_values(names)
+    proxies = {}
+    values = []
+
+    names.each_with_index do |name, i|
+      value = yield name, i
+      if value.marshalable?
+        dump = Marshal.dump(value)
+        values << "#{name} = Marshal.load(#{dump.inspect})"
+      else
+        proxies[value.hash] = value
+        values << "#{name} = #{RobotArmy::Proxy.generator_for(value)}"
+      end
+    end
+
+    return values, proxies
+  end
+end

data/lib/robot-army/eval_command.rb

@@ -0,0 +1,17 @@
+class RobotArmy::EvalCommand
+  def initialize
+    yield self if block_given?
+  end
+
+  attr_accessor :user
+
+  attr_accessor :proc
+
+  attr_accessor :args
+
+  attr_accessor :context
+
+  attr_accessor :dependencies
+
+  attr_accessor :keychain
+end

data/lib/robot-army/keychain.rb

@@ -0,0 +1,10 @@
+class RobotArmy::Keychain
+  def get_password_for_user_on_host(user, host)
+    read_with_prompt("[sudo] password for #{user}@#{host}: ")
+  end
+
+  def read_with_prompt(prompt)
+    require 'highline'
+    HighLine.new.ask(prompt) {|q| q.echo = false}
+  end
+end

data/lib/robot-army/marshal_ext.rb

@@ -1,17 +1,17 @@
 module Marshal
   class <<self
     # Determines whether a given object can be dumped.
-    # 
+    #
     # @param object Object
     #   The object to check.
-    # 
+    #
     # @return [Boolean]
-    #   +true+ if dumping the object does not raise an error, 
+    #   +true+ if dumping the object does not raise an error,
     #   +false+ if a +TypeError+ is raised.
-    # 
+    #
     # @raise Exception
     #   Whatever +Marshal.dump+ might raise that isn't a +TypeError+.
-    # 
+    #
     def can_dump?(object)
       begin
         Marshal.dump(object)
@@ -25,9 +25,28 @@ end
 
 class Object
   # Syntactic sugar for +Marshal.can_dump?+.
-  # 
+  #
   # @see Marshal.can_dump?
   def marshalable?
-    Marshal.can_dump?(self)
+    Marshal.can_dump?(self) &&
+    instance_variables.all? do |ivar|
+      instance_variable_get(ivar).marshalable?
+    end
+  end
+end
+
+class Array
+  def marshalable?
+    super &&
+    all? {|item| item.marshalable?}
+  end
+end
+
+class Hash
+  def marshalable?
+    super &&
+    keys.marshalable? &&
+    values.marshalable? &&
+    default.marshalable?
   end
 end

data/lib/robot-army/remote_evaler.rb

@@ -0,0 +1,59 @@
+class RobotArmy::RemoteEvaler
+  attr_reader :connection, :command, :options, :proxies
+
+  def initialize(connection, command)
+    @connection = connection
+    @command = command
+  end
+
+  def execute_command
+    @options, @proxies = RobotArmy::EvalBuilder.build(command)
+    send_eval_command
+    return loop_until_done
+  end
+
+  private
+
+  def send_eval_command
+    debug("Evaling code remotely:\n#{options[:code]}")
+    connection.post(:command => :eval, :data => options)
+  end
+
+  def loop_until_done
+    catch :done do
+      loop { process_response(connection.messenger.get) }
+    end
+  end
+
+  def process_response(response)
+    case response[:status]
+    when 'proxy'
+      handle_proxy_response(response)
+    when 'password'
+      debug("Got password request: #{response[:data].inspect}")
+      connection.post :status => 'ok', :data => command.keychain.get_password_for_user_on_host(response[:data][:user], connection.host)
+    else
+      begin
+        throw :done, connection.handle_response(response)
+      rescue RobotArmy::Warning => e
+        $stderr.puts "WARNING: #{e.message}"
+        throw :done, nil
+      end
+    end
+  end
+
+  def handle_proxy_response(response)
+    begin
+      proxy = proxies[response[:data][:hash]]
+      data = proxy.send(*response[:data][:call])
+      if data.marshalable?
+        connection.post :status => 'ok', :data => data
+      else
+        proxies[data.hash] = data
+        connection.post :status => 'proxy', :data => data.hash
+      end
+    rescue Object => e
+      connection.post :status => 'error', :data => e
+    end
+  end
+end

data/lib/robot-army/ruby2ruby_ext.rb

@@ -2,30 +2,18 @@ class Proc
   def arguments
     (to_ruby[/\Aproc \{ \|([^\|]+)\|/, 1] || '').split(/\s*,\s*/)
   end
-  
-  def to_ruby_with_body_flag(only_body=false)
-    only_body ? to_method.to_ruby(true) : to_ruby_without_body_flag
+
+  def to_ruby_without_proc_wrapper
+    to_ruby[/\Aproc\s*\{\s*(\|[^\|]+\|)?\s*(.*?)\s*\}\Z/m, 2] || raise("Unable to parse proc's Ruby: #{to_ruby}")
   end
-  
-  alias :to_ruby_without_body_flag :to_ruby
-  alias :to_ruby :to_ruby_with_body_flag
 end
 
 class Method
   def arguments
     (to_ruby[/\A(def [^\s\(]+)(?:\(([^\)]*)\))?/, 2] || '').split(/\s*,\s*/)
   end
-  
-  def to_ruby_with_body_flag(only_body=false)
-    ruby = self.to_ruby_without_body_flag
-    if only_body
-      ruby.sub!(/\A(def [^\s\(]+)(?:\(([^\)]*)\))?/, '')   # move args
-      ruby.sub!(/end\Z/, '')                          # strip end
-    end
-    ruby.gsub!(/\s+$/, '')                            # trailing WS bugs me
-    ruby
+
+  def to_ruby_without_method_declaration
+    to_ruby[/\Adef [^\s\(]+(?:\([^\)]*\))?\s*(.*?)\s*end\Z/m, 1] || raise("Unable to parse method's Ruby: #{to_ruby}")
   end
-  
-  alias :to_ruby_without_body_flag :to_ruby
-  alias :to_ruby :to_ruby_with_body_flag
 end

data/lib/robot-army/task_master.rb

@@ -1,46 +1,49 @@
 module RobotArmy
   # The place where the magic happens
-  # 
+  #
   # ==== Types (shortcuts for use in this file)
   # HostList:: <Array[String], String, nil>
   class TaskMaster < Thor
+
+  no_tasks do
+
     def initialize(*args)
       super
       @dep_loader = DependencyLoader.new
     end
-    
+
     # Gets or sets a single host that instances of +RobotArmy::TaskMaster+ subclasses will use.
-    # 
+    #
     # @param host [String, :localhost]
     #   The fully-qualified domain name to connect to.
-    # 
+    #
     # @return [String, :localhost]
     #   The current value for the host.
-    # 
+    #
     # @raise RobotArmy::HostArityError
-    #   If you're using the getter form of this method and you've already 
+    #   If you're using the getter form of this method and you've already
     #   set multiple hosts, an error will be raised.
-    # 
+    #
     def self.host(host=nil)
       if host
         @hosts = nil
         @host = host
       elsif @hosts
-        raise RobotArmy::HostArityError, 
+        raise RobotArmy::HostArityError,
           "There are #{@hosts.size} hosts, so calling host doesn't make sense"
       else
         @host
       end
     end
-    
+
     # Gets or sets the hosts that instances of +RobotArmy::TaskMaster+ subclasses will use.
-    # 
+    #
     # @param hosts [Array[String]]
     #   A list of fully-qualified domain names to connect to.
-    # 
+    #
     # @return [Array[String]]
     #   The current list of hosts.
-    # 
+    #
     def self.hosts(hosts=nil)
       if hosts
         @host = nil
@@ -51,42 +54,42 @@ module RobotArmy
         @hosts || []
       end
     end
-    
+
     # Gets the first host for this instance of +RobotArmy::TaskMaster+.
-    # 
+    #
     # @return [String, :localhost]
     #   The host value to use.
-    # 
+    #
     # @raise RobotArmy::HostArityError
-    #   If you're using the getter form of this method and you've already 
+    #   If you're using the getter form of this method and you've already
     #   set multiple hosts, an error will be raised.
-    # 
+    #
     def host
       if @host
         @host
       elsif @hosts
-        raise RobotArmy::HostArityError, 
+        raise RobotArmy::HostArityError,
           "There are #{@hosts.size} hosts, so calling host doesn't make sense"
       else
         self.class.host
       end
     end
-    
+
     # Sets a single host for this instance of +RobotArmy::TaskMaster+.
-    # 
+    #
     # @param host [String, :localhost]
     #   The host value to use.
-    # 
+    #
     def host=(host)
       @hosts = nil
       @host = host
     end
-    
+
     # Gets the hosts for the instance of +RobotArmy::TaskMaster+.
-    # 
+    #
     # @return [Array[String]]
     #   A list of hosts.
-    # 
+    #
     def hosts
       if @hosts
         @hosts
@@ -96,104 +99,104 @@ module RobotArmy
         self.class.hosts
       end
     end
-    
+
     # Sets the hosts for this instance of +RobotArmy::TaskMaster+.
-    # 
+    #
     # @param hosts [Array[String]]
     #   A list of hosts.
-    # 
+    #
     def hosts=(hosts)
       @host = nil
       @hosts = hosts
     end
-    
+
     # Gets an open connection for the host this instance is configured to use.
-    # 
+    #
     # @return RobotArmy::Connection
     #   An open connection with an active Ruby process.
-    # 
+    #
     def connection(host)
       RobotArmy::GateKeeper.shared_instance.connect(host)
     end
-    
-    # Runs a block of Ruby on the machine specified by a host string as root 
+
+    # Runs a block of Ruby on the machine specified by a host string as root
     # and returns the return value of the block. Example:
-    # 
+    #
     #   sudo { `shutdown -r now` }
-    # 
+    #
     # You may also specify a user other than root. In this case +sudo+ is the
     # same as +remote+:
-    # 
+    #
     #   sudo(:user => 'www-data') { `/etc/init.d/apache2 restart` }
-    # 
+    #
     # @param host [String, :localhost]
-    #   The fully-qualified domain name of the machine to connect to, or 
+    #   The fully-qualified domain name of the machine to connect to, or
     #   +:localhost+ if you want to use the same machine.
-    # 
+    #
     # @options options
     #   :user -> String => shell user
-    # 
+    #
     # @raise Exception
     #   Whatever is raised by the block.
-    # 
+    #
     # @return [Object]
     #   Whatever is returned by the block.
-    # 
+    #
     # @see remote
     def sudo(hosts=self.hosts, options={}, &proc)
       options, hosts = hosts, self.hosts if hosts.is_a?(Hash)
       remote hosts, {:user => 'root'}.merge(options), &proc
     end
-    
-    # Runs a block of Ruby on the machine specified by a host string and 
+
+    # Runs a block of Ruby on the machine specified by a host string and
     # returns the return value of the block. Example:
-    # 
+    #
     #   remote { "foo" } # => "foo"
-    # 
-    # Local variables accessible from the block are also passed along to the 
+    #
+    # Local variables accessible from the block are also passed along to the
     # remote process:
-    # 
+    #
     #   foo = "bar"
     #   remote { foo } # => "bar"
-    # 
-    # Objects which can't be marshalled, such as IO streams, will be proxied 
+    #
+    # Objects which can't be marshalled, such as IO streams, will be proxied
     # instead:
-    # 
+    #
     #   file = File.open("README.markdown", "r")
     #   remote { file.gets } # => "Robot Army\n"
-    # 
+    #
     # @param hosts [HostList]
     #   Which hosts to run the block on.
-    # 
+    #
     # @options options
     #   :user -> String => shell user
-    # 
+    #
     # @raise Exception
     #   Whatever is raised by the block.
-    # 
+    #
     # @return [Object]
     #   Whatever is returned by the block.
-    # 
+    #
     def remote(hosts=self.hosts, options={}, &proc)
       options, hosts = hosts, self.hosts if hosts.is_a?(Hash)
       results = Array(hosts).map {|host| remote_eval({:host => host}.merge(options), &proc) }
       results.size == 1 ? results.first : results
     end
-    
+
     # Copies src to dest on each host.
-    # 
+    #
     # @param src [String]
     #   A local file to copy.
-    # 
+    #
     # @param dest [String]
     #   The path of a remote file to copy to.
-    # 
+    #
     # @raise Errno::EACCES
     #   If the destination path cannot be written to.
-    # 
+    #
     # @raise Errno::ENOENT
     #   If the source path cannot be read.
-    # 
+    #
     def scp(src, dest, hosts=self.hosts)
       Array(hosts).each do |host|
         output = `scp -q #{src} #{"#{host}:" unless host == :localhost}#{dest} 2>&1`
@@ -204,35 +207,35 @@ module RobotArmy
           raise Errno::ENOENT, output.chomp
         end unless $?.exitstatus == 0
       end
-      
+
       return nil
     end
-    
+
     # Copies path to a temporary directory on each host.
-    # 
+    #
     # @param path [String]
     #   A local file to copy.
-    # 
+    #
     # @param hosts [HostList]
     #   Which hosts to connect to.
-    # 
+    #
     # @yield [path]
     #   Yields the path of the newly copied file on each remote host.
-    # 
+    #
     # @yieldparam [String] path
-    #   The path of the file under in a new directory under a 
+    #   The path of the file under in a new directory under a
     #   temporary directory on the remote host.
-    # 
+    #
     # @return [Array<String>]
     #   An array of destination paths.
-    # 
+    #
     def cptemp(path, hosts=self.hosts, options={}, &block)
       hosts, options = self.hosts, hosts if hosts.is_a?(Hash)
-      
+
       results = remote(hosts, options) do
         File.join(%x{mktemp -d -t robot-army.XXXX}.chomp, File.basename(path))
       end
-      
+
       me = ENV['USER']
       host_and_path = Array(hosts).zip(Array(results))
       # copy them over
@@ -245,161 +248,70 @@ module RobotArmy
       results = host_and_path.map do |host, tmp|
         remote(host, options.merge(:args => [tmp]), &block)
       end if block
-      
+
+      # delete it when we're done
+      RobotArmy::AtExit.shared_instance.at_exit do
+        host_and_path.each do |host, tmp|
+          remote(host, options) do
+            FileUtils.rm_rf(tmp)
+          end
+        end
+      end
+
       results.size == 1 ? results.first : results
     end
-    
+
     # Add a gem dependency this TaskMaster checks for on each remote host.
-    # 
+    #
     # @param dep [String]
     #   The name of the gem to check for.
-    # 
+    #
     # @param ver [String]
     #   The version string of the gem to check for.
-    # 
+    #
     def dependency(dep, ver = nil)
       @dep_loader.add_dependency dep, ver
     end
-    
+
   private
-    
+
     def say(something)
       something = HighLine.new.color(something, :bold) if defined?(HighLine)
       puts "** #{something}"
     end
-    
-    # Dumps the values associated with the given names for transport.
-    # 
-    # @param names [Array[String]]
-    #   The names of the variables to dump.
-    # 
-    # @yield [name, index]
-    #   Yields the name and its index and expects 
-    #   to get the corresponding value.
-    # 
-    # @yieldparam [String] name
-    #   The name of the value for the block to return.
-    # 
-    # @yieldparam [Fixnum] index
-    #   The index of the value for the block to return.
-    # 
-    # @return [(Array[Object], Hash[Fixnum => Object])]
-    #   The pair +values+ and +proxies+.
-    # 
-    def dump_values(names)
-      proxies = {}
-      values = []
-      
-      names.each_with_index do |name, i|
-        value = yield name, i
-        if value.marshalable?
-          dump = Marshal.dump(value)
-          values << "#{name} = Marshal.load(#{dump.inspect})"
-        else
-          proxies[value.hash] = value
-          values << "#{name} = #{RobotArmy::Proxy.generator_for(value)}"
-        end
-      end
-      
-      return values, proxies
-    end
-    
+
     # Handles remotely eval'ing a Ruby Proc.
-    # 
+    #
     # @options options
     #   :host -> [String, :localhost] => remote host
     #   :user -> String => shell user
     #   :password -> [String, nil] => sudo password
-    # 
+    #
     # @return Object
     #   Whatever the block returns.
-    # 
+    #
     # @raise Exception
     #   Whatever the block raises.
-    # 
+    #
     def remote_eval(options, &proc)
-      host = options[:host]
-      conn = connection(host)
-      procargs = options[:args] || []
-      proxies  = { self.hash => self }
-      
-      ##
-      ## build the code to send it
-      ##
-      
-      # fix stack traces
-      file, line = eval('[__FILE__, __LINE__]', proc.binding)
-      
-      # include local variables
-      local_variables = eval('local_variables', proc.binding)
-      locals, lproxies = dump_values(local_variables) { |name,| eval(name, proc.binding) }
-      proxies.merge! lproxies
-      
-      # include arguments
-      args, aproxies = dump_values(proc.arguments) { |_, i| procargs[i] }
-      proxies.merge! aproxies
-      
-      # include dependency loader
-      dep_loading = "Marshal.load(#{Marshal.dump(@dep_loader).inspect}).load!"
-      
-      # get the code for the proc
-      proc = "proc{ #{proc.to_ruby(true)} }"
-      messenger = "RobotArmy::Messenger.new($stdin, $stdout)"
-      context = "RobotArmy::Proxy.new(#{messenger}, #{self.hash.inspect})"
-      
-      code = %{
-        #{dep_loading} # load dependencies
-        #{(locals+args).join("\n")} # all local variables
-        #{context}.__proxy_instance_eval(&#{proc}) # run the block
-      }
-      
-      options[:file] = file
-      options[:line] = line
-      options[:code] = code
-      
-      ##
-      ## send the child a message
-      ##
-      
-      conn.post(:command => :eval, :data => options)
-      
-      ##
-      ## get and evaluate the response
-      ##
-      
-      loop do
-        # we want to loop until we get something other than "proxy"
-        response = conn.messenger.get
-        case response[:status]
-        when 'proxy'
-          begin
-            proxy = proxies[response[:data][:hash]]
-            data = proxy.send(*response[:data][:call])
-            if data.marshalable?
-              conn.post :status => 'ok', :data => data
-            else
-              proxies[data.hash] = data
-              conn.post :status => 'proxy', :data => data.hash
-            end
-          rescue Object => e
-            conn.post :status => 'error', :data => e
-          end
-        when 'password'
-          conn.post :status => 'ok', :data => ask_for_password(host, response[:data])
-        else
-          begin
-            return conn.handle_response(response)
-          rescue RobotArmy::Warning => e
-            $stderr.puts "WARNING: #{e.message}"
-            return nil
-          end
-        end
-      end
+      evaler = RemoteEvaler.new(connection(options[:host]), EvalCommand.new do |command|
+        command.user = options[:user]
+        command.proc = proc
+        command.args = options[:args] || []
+        command.context = self
+        command.dependencies = @dep_loader
+        command.keychain = keychain
+      end)
+
+      return evaler.execute_command
     end
-    
-    def ask_for_password(host, data={})
-      require 'highline'
-      HighLine.new.ask("[sudo] password for #{data[:user]}@#{host}: ") {|q| q.echo = false}
+
+    # Returns the default password manager. This should be
+    # overridden if you wish to have different sudo behavior.
+    def keychain
+      @keychain ||= Keychain.new
     end
   end
+
+  end
 end