wesabe-robot-army 0.1 → 0.1.1

data/README.markdown

@@ -30,7 +30,5 @@ Example
 Known Issues
 ------------
 
-  * No attempt is made to support `sudo` yet
-  * Code executed in `remote` has no access to instance variables, globals, or methods on `self`
-  * Multiple hosts are not yet supported
+  * Code executed in `remote` has no access to instance variables or globals
   * Probably doesn't work with Windows

data/lib/robot-army/connection.rb

@@ -1,8 +1,10 @@
 class RobotArmy::Connection
-  attr_reader :host, :messenger
+  attr_reader :host, :user, :password, :messenger
   
-  def initialize(host)
+  def initialize(host, user=nil, password=nil)
     @host = host
+    @user = user
+    @password = password
     @closed = true
   end
   
@@ -24,34 +26,73 @@ class RobotArmy::Connection
     end
   end
   
+  def password_prompt
+    @password_prompt ||= RobotArmy.random_string
+  end
+  
+  def asking_for_password?(stream)
+    if RobotArmy::IO.has_data?(stream)
+      data = RobotArmy::IO.read_data(stream)
+      debug "read #{data.inspect}"
+      return data && data =~ /#{password_prompt}\n*$/
+    end
+  end
+  
+  def answer_sudo_prompt(stdin, stderr)
+    tries = password.is_a?(Proc) ? 3 : 1
+    
+    tries.times do
+      if asking_for_password?(stderr)
+        # ask, and you shall receive
+        stdin.puts(password.is_a?(Proc) ?
+          password.call : password.to_s)
+      end
+    end
+    
+    if asking_for_password?(stderr)
+      # ack, that didn't work, bail
+      stdin.puts
+      stderr.readpartial(1024)
+      raise RobotArmy::InvalidPassword
+    end
+  end
+  
   def start_child
     begin
       ##
       ## bootstrap the child process
       ##
-    
+      
       # small hack to retain control of stdin
       cmd = %{ruby -rbase64 -e "eval(Base64.decode64(STDIN.gets(%(|))))"}
-      cmd = "ssh #{host} '#{cmd}'" if host
-    
-      stdin, stdout, stderr = Open3.popen3 cmd
-      stdin.sync = stdout.sync = stderr.sync = true
-    
+      if user
+        # use sudo with user's home dir, custom prompt, reading password from stdin
+        cmd = %{sudo -H -u #{user} -p #{password_prompt} -S #{cmd}}
+      end
+      cmd = "ssh #{host} '#{cmd}'" unless host == :localhost
+      debug "running #{cmd}"
+      
       loader.libraries.replace $TESTING ? 
         [File.join(File.dirname(__FILE__), '..', 'robot-army')] : %w[rubygems robot-army]
-    
+      
+      stdin, stdout, stderr = Open3.popen3 cmd
+      stdin.sync = stdout.sync = stderr.sync = true
+      
+      # look for the prompt
+      answer_sudo_prompt(stdin, stderr) if user && password
+      
       ruby = loader.render
       code = Base64.encode64(ruby)
       stdin << code << '|'
-    
-    
+      
+      
       ##
       ## make sure it was loaded okay
       ##
-    
+      
       @messenger = RobotArmy::Messenger.new(stdout, stdin)
       response = messenger.get
-    
+      
       if response
         case response[:status]
         when 'error'
@@ -85,6 +126,15 @@ class RobotArmy::Connection
     end
   end
   
+  def info
+    post(:command => :info)
+    handle_response(get)
+  end
+  
+  def get
+    messenger.get
+  end
+  
   def post(*args)
     messenger.post(*args)
   end
@@ -99,8 +149,26 @@ class RobotArmy::Connection
     @closed = true
   end
   
-  def self.localhost(&block)
-    conn = new(nil)
+  def handle_response(response)
+    self.class.handle_response(response)
+  end
+  
+  def self.handle_response(response)
+    debug "handling response=#{response.inspect}"
+    case response[:status]
+    when 'ok'
+      return response[:data]
+    when 'error'
+      raise response[:data]
+    when 'warning'
+      raise RobotArmy::Warning, response[:data]
+    else
+      raise RuntimeError, "Unknown response status from remote process: #{response[:status].inspect}"
+    end
+  end
+  
+  def self.localhost(user=nil, password=nil, &block)
+    conn = new(:localhost, user, password)
     block ? conn.open(&block) : conn
   end
 end

data/lib/robot-army/dependency_loader.rb

@@ -0,0 +1,38 @@
+module RobotArmy
+  class DependencyError < StandardError; end
+  
+  class DependencyLoader
+    attr_reader :dependencies
+    
+    def initialize
+      @dependencies = []
+    end
+    
+    def add_dependency(name, version_str=nil)
+      dep = [name]
+      dep << version_str if version_str
+      @dependencies << dep
+    end
+    
+    def load!
+      errors = []
+      
+      @dependencies.each do |name, version|
+        begin
+          if version
+            gem name, version
+          else
+            gem name
+          end
+        rescue Gem::LoadError => e
+          errors << e.message
+        end
+      end
+      
+      unless errors.empty?
+        raise DependencyError.new(errors.join("\n"))
+      end
+    end
+    
+  end
+end

data/lib/robot-army/gate_keeper.rb

@@ -1,10 +1,16 @@
 class RobotArmy::GateKeeper
+  attr_reader :connection_class
+  
+  def initialize(connection_class=RobotArmy::OfficerConnection)
+    @connection_class = connection_class
+  end
+  
   def connect(host)
     connections[host] ||= establish_connection(host)
   end
   
   def establish_connection(host)
-    connection = connections[host] = RobotArmy::Connection.new(host)
+    connection = connections[host] = connection_class.new(host)
     connection.open
   end
   

data/lib/robot-army/io.rb

@@ -0,0 +1,106 @@
+class RobotArmy::IO
+  attr_reader :name
+  
+  # Starts capturing output of the named stream.
+  # 
+  def start_capture
+    eval "$#{name} = self"
+  end
+  
+  # Stops capturing output of the named stream.
+  # 
+  def stop_capture
+    eval "$#{name} = #{name.upcase}"
+  end
+  
+  def puts(*args) #:nodoc:
+    post capture(:puts, *args)
+  end
+  
+  def print(*args) #:nodoc:
+    post capture(:print, *args)
+  end
+  
+  def write(*args) #:nodoc:
+    post capture(:write, *args)
+  end
+  
+private
+  
+  def initialize(name)
+    @name = name.to_s
+    start_capture
+  end
+  
+  def post(string)
+    RobotArmy.upstream.post(:status => 'output', :data => {:stream => name, :string => string})
+  end
+  
+  def capture(*call)
+    stream = StringIO.new
+    stream.send(*call)
+    stream.string
+  end
+  
+  class <<self
+    # Determines whether the given stream has any data to be read.
+    # 
+    # @param stream [IO]
+    #   The +IO+ stream to check.
+    # 
+    # @return [Boolean]
+    #   +true+ if stream has data to be read, +false+ otherwise.
+    # 
+    def has_data?(stream)
+      selected, _ = IO.select([stream], nil, nil, 0.5)
+      return selected && !selected.empty?
+    end
+
+    # Reads immediately available data from the given stream.
+    # 
+    #   # echo foo | ruby test.rb
+    #   RobotArmy::IO.read_data($stdin) # => "foo\n"
+    # 
+    # @param stream [IO]
+    #   The +IO+ stream to read from.
+    # 
+    # @return [String]
+    #   The data read from the stream.
+    # 
+    def read_data(stream)
+      data = []
+      data << stream.readpartial(1024) while has_data?(stream)
+      return data.join
+    end
+    
+    # Redirects the named stream to a +StringIO+.
+    # 
+    #   RobotArmy::IO.capture(:stdout) { puts "foo" } # => "foo\n"
+    # 
+    #   RobotArmy::IO.silence(:stderr) { system "rm non-existent-file" }
+    # 
+    # @param stream [Symbol]
+    #   The name of the stream to redirect (i.e. +:stderr+, +:stdout+).
+    # 
+    # @yield
+    #   The block whose output we should capture.
+    # 
+    # @return [String]
+    #   The string result of the output produced by the block.
+    # 
+    def capture(stream)
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").string
+      ensure 
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+    
+    alias_method :silence, :capture
+  end
+end

data/lib/robot-army/loader.rb

@@ -12,6 +12,7 @@ class RobotArmy::Loader
         ## setup
         ##
         
+        $TESTING = #{$TESTING.inspect}
         $stdout.sync = $stdin.sync = true
         #{libraries.map{|l| "require #{l.inspect}"}.join("\n")}
         
@@ -20,8 +21,9 @@ class RobotArmy::Loader
         ## local Robot Army objects to communicate with the parent
         ##
         
-        loader = RobotArmy::Loader.new
-        loader.messenger = RobotArmy::Messenger.new($stdin, $stdout)
+        loader = #{self.class.name}.new
+        RobotArmy.upstream = RobotArmy::Messenger.new($stdin, $stdout)
+        loader.messenger = RobotArmy.upstream
         loader.messenger.post(:status => 'ok')
         
         ##

data/lib/robot-army/marshal_ext.rb

@@ -0,0 +1,33 @@
+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, 
+    #   +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)
+        return true
+      rescue TypeError
+        return false
+      end
+    end
+  end
+end
+
+class Object
+  # Syntactic sugar for +Marshal.can_dump?+.
+  # 
+  # @see Marshal.can_dump?
+  def marshalable?
+    Marshal.can_dump?(self)
+  end
+end

data/lib/robot-army/messenger.rb

@@ -7,7 +7,6 @@ module RobotArmy
     end
     
     def post(response)
-      debug "post(#{response.inspect})"
       dump = Marshal.dump(response)
       dump = Base64.encode64(dump) + '|'
       output << dump

data/lib/robot-army/officer.rb

@@ -2,8 +2,24 @@ class RobotArmy::Officer < RobotArmy::Soldier
   def run(command, data)
     case command
     when :eval
-      RobotArmy::Connection.localhost do |local|
+      debug "officer delegating eval command for user=#{data[:user].inspect}"
+      RobotArmy::Connection.localhost(data[:user], proc{ ask_for_password(data[:user]) }) do |local|
         local.post(:command => command, :data => data)
+        
+        loop do
+          # we want to stay in this loop as long as we 
+          # have proxy requests coming back from our child
+          response = local.get
+          case response[:status]
+          when 'proxy'
+            # forward proxy requests on to our parent
+            messenger.post(response)
+            # and send the response back to our child
+            local.post(messenger.get)
+          else
+            return RobotArmy::Connection.handle_response(response)
+          end
+        end
       end
     when :exit
       super
@@ -11,4 +27,9 @@ class RobotArmy::Officer < RobotArmy::Soldier
       super
     end
   end
+  
+  def ask_for_password(user)
+    messenger.post(:status => 'password', :data => {:as => user, :user => ENV['USER']})
+    RobotArmy::Connection.handle_response messenger.get
+  end
 end

data/lib/robot-army/officer_connection.rb

@@ -0,0 +1,5 @@
+class RobotArmy::OfficerConnection < RobotArmy::Connection
+  def loader
+    @loader ||= RobotArmy::OfficerLoader.new
+  end
+end

data/lib/robot-army/officer_loader.rb

@@ -0,0 +1,13 @@
+class RobotArmy::OfficerLoader < RobotArmy::Loader
+  def load
+    # create a soldier
+    soldier = safely_or_die{ RobotArmy::Officer.new(messenger) }
+    
+    # use the soldier to start listening to incoming commands
+    # at this point everything has been loaded successfully, so we
+    # don't have to exit if an exception is thrown
+    loop do
+      safely{ soldier.listen }
+    end
+  end
+end

data/lib/robot-army/proxy.rb

@@ -0,0 +1,26 @@
+class RobotArmy::Proxy
+  alias_method :__proxy_instance_eval, :instance_eval
+  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  
+  def initialize(messenger, hash)
+    @messenger = messenger
+    @hash = hash
+  end
+  
+  def self.generator_for(object)
+    "RobotArmy::Proxy.new(RobotArmy.upstream, #{object.hash.inspect})"
+  end
+  
+private
+  
+  def method_missing(*args, &block)
+    @messenger.post(:status => 'proxy', :data => {:hash => @hash, :call => args})
+    response = @messenger.get
+    case response[:status]
+    when 'proxy'
+      return RobotArmy::Proxy.new(@messenger, response[:data])
+    else
+      return RobotArmy::Connection.handle_response(response)
+    end
+  end
+end

data/lib/robot-army/ruby2ruby_ext.rb

@@ -1,7 +1,10 @@
 class Proc
+  def arguments
+    (to_ruby[/\Aproc \{ \|([^\|]+)\|/, 1] || '').split(/\s*,\s*/)
+  end
+  
   def to_ruby_with_body_flag(only_body=false)
-    ruby = to_ruby_without_body_flag
-    only_body ? "#{ruby}.call" : ruby
+    only_body ? to_method.to_ruby(true) : to_ruby_without_body_flag
   end
   
   alias :to_ruby_without_body_flag :to_ruby
@@ -9,10 +12,14 @@ class Proc
 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!(/\A(def [^\s\(]+)(?:\(([^\)]*)\))?/, '')   # move args
       ruby.sub!(/end\Z/, '')                          # strip end
     end
     ruby.gsub!(/\s+$/, '')                            # trailing WS bugs me

data/lib/robot-army/soldier.rb

@@ -8,12 +8,22 @@ class RobotArmy::Soldier
   def listen
     request  = messenger.get
     result   = run(request[:command], request[:data])
-    response = {:status => 'ok', :data => result}
+    if result.marshalable?
+      response = {:status => 'ok', :data => result}
+    else
+      response = {
+        :status => 'warning', 
+        :data => "ignoring invalid remote return value #{result.inspect}"}
+    end
+    debug "#{self.class} post(#{response.inspect})"
     messenger.post response
   end
   
   def run(command, data)
+    debug "#{self.class} running command=#{command.inspect}"
     case command
+    when :info
+      {:pid => Process.pid, :type => self.class.name}
     when :eval
       instance_eval(data[:code], data[:file], data[:line])
     when :exit

data/lib/robot-army/task_master.rb

@@ -1,23 +1,328 @@
 module RobotArmy
+  # The place where the magic happens
+  # 
+  # ==== Types (shortcuts for use in this file)
+  # HostList:: <Array[String], String, nil>
   class TaskMaster < Thor
+    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 
+    #   set multiple hosts, an error will be raised.
+    # 
     def self.host(host=nil)
-      @host = host if host
-      @host
+      if host
+        @hosts = nil
+        @host = host
+      elsif @hosts
+        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
+        @hosts = hosts
+      elsif @host
+        [@host]
+      else
+        @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 
+    #   set multiple hosts, an error will be raised.
+    # 
     def host
-      self.class.host
+      if @host
+        @host
+      elsif @hosts
+        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
+      elsif @host
+        [@host]
+      else
+        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 
+    # 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 
+    #   +: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 
+    # returns the return value of the block. Example:
+    # 
+    #   remote { "foo" } # => "foo"
+    # 
+    # 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 
+    # 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`
+        case output
+        when /Permission denied/i
+          raise Errno::EACCES, output.chomp
+        when /No such file or directory/i
+          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 
+    #   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
+      host_and_path.each do |host, tmp|
+        sudo(host) { FileUtils.chown(me, nil, File.dirname(tmp)) } if options[:user]
+        scp path, tmp, host
+        sudo(host) { FileUtils.chown(options[:user], nil, File.dirname(tmp)) } if options[:user]
+      end
+      # call the block on each host
+      results = host_and_path.map do |host, tmp|
+        remote(host, options.merge(:args => [tmp]), &block)
+      end if block
+      
+      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
     
-    def connection
-      RobotArmy::GateKeeper.shared_instance.connect(host)
+    # 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
     
-    def remote(host=self.host, &proc)
+    # 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
       ##
@@ -26,40 +331,75 @@ module RobotArmy
       file, line = eval('[__FILE__, __LINE__]', proc.binding)
       
       # include local variables
-      locals = eval('local_variables', proc.binding).map do |name|
-        "#{name} = Marshal.load(#{Marshal.dump(eval(name, proc.binding)).inspect})"
-      end
+      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 = %{
-        #{locals.join("\n")}  # all local variables
-        #{proc.to_ruby(true)} # the proc itself
+        #{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
       ##
       
-      connection.messenger.post(:command => :eval, :data => {
-        :code => code, 
-        :file => file, 
-        :line => line
-      })
+      conn.post(:command => :eval, :data => options)
       
       ##
       ## get and evaluate the response
       ##
       
-      response = connection.messenger.get
-      
-      case response[:status]
-      when 'ok'
-        return response[:data]
-      when 'error'
-        raise response[:data]
-      else
-        raise RuntimeError, "Unknown response status from remote process: #{response[:status]}"
+      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
     end
+    
+    def ask_for_password(host, data={})
+      require 'highline'
+      HighLine.new.ask("[sudo] password for #{data[:user]}@#{host}: ") {|q| q.echo = false}
+    end
   end
 end

data/lib/robot-army.rb

@@ -1,9 +1,38 @@
-%w[rubygems open3 base64 thor ruby2ruby].each do |library|
-  require library
-end
+require 'rubygems'
+require 'open3'
+require 'base64'
+require 'thor'
+gem 'ruby2ruby', '=1.1.9'
+require 'ruby2ruby'
+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
+  class InvalidPassword < StandardError
+    def message
+      "Invalid password"
+    end
+  end
   class RobotArmy::Exit < Exception
     attr_accessor :status
     
@@ -11,9 +40,27 @@ module RobotArmy
       @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 soldier officer messenger task_master connection gate_keeper ruby2ruby_ext].each do |file|
+%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)
 end
 
@@ -22,5 +69,7 @@ at_exit do
 end
 
 def debug(*whatever)
-  File.open('/tmp/robot-army', 'a') { |f| f.puts "[#{Process.pid}] #{whatever.join(' ')}" }
+  File.open('/tmp/robot-army.log', 'a') do |f|
+    f.puts "[#{Process.pid}] #{whatever.join(' ')}"
+  end if $TESTING
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wesabe-robot-army
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: 0.1.1
 platform: ruby
 authors: 
 - Brian Donovan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-20 00:00:00 -07:00
+date: 2008-12-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -17,9 +17,9 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">"
+    - - "="
       - !ruby/object:Gem::Version 
-        version: 1.1.7
+        version: 1.1.9
     version: 
 - !ruby/object:Gem::Dependency 
   name: thor
@@ -45,10 +45,16 @@ files:
 - Rakefile
 - lib/robot-army
 - lib/robot-army/connection.rb
+- lib/robot-army/dependency_loader.rb
 - lib/robot-army/gate_keeper.rb
+- lib/robot-army/io.rb
 - lib/robot-army/loader.rb
+- lib/robot-army/marshal_ext.rb
 - lib/robot-army/messenger.rb
 - lib/robot-army/officer.rb
+- lib/robot-army/officer_connection.rb
+- lib/robot-army/officer_loader.rb
+- lib/robot-army/proxy.rb
 - lib/robot-army/ruby2ruby_ext.rb
 - lib/robot-army/soldier.rb
 - lib/robot-army/task_master.rb
@@ -75,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: robot-army
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Deploy using Thor by executing Ruby remotely