robot-army 0.1.8

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2007 Wesabe, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.markdown

@@ -0,0 +1,34 @@
+Robot Army
+==========
+
+Robot Army is deploy scripting which offers remote execution of Ruby in addition to the usual shell scripting offered by other deploy packages.
+
+If you want to test this, be sure that the `robot-army` gem is installed on *both* the client and server machines. You should get an error if you try to execute it against a server with it installed.
+
+Example
+-------
+
+    class AppServer < RobotArmy::TaskMaster
+      host 'app1.prod.example.com'
+      
+      desc "time", "Get the time on the server (delta will be slightly off depending on SSH delay)"
+      def time
+        rtime = remote{ Time.now }
+        ltime = Time.now
+        
+        say "The time on #{host} is #{rtime}, " +
+            "#{(rtime-ltime).abs} seconds #{rtime < ltime ? 'behind' : 'ahead of'} localhost"
+      end
+      
+      desc "deployed_revision", "Gets the deployed revision"
+      def deployed_revision
+        say "Checking deployed revision on #{host}"
+        say "Deployed revision: #{remote{ File.read("/opt/app/current/REVISION") }}"
+      end
+    end
+
+Known Issues
+------------
+
+  * Code executed in `remote` has no access to instance variables or globals
+  * Probably doesn't work with Windows

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rubygems'
+  require 'thor'
+  
+  $stderr.puts "Robot Army uses thor, not rake. Here are the available tasks:"
+  exec "thor -T"
+rescue LoadError
+  $stderr.puts "Robot Army uses thor, not rake. Please install thor."
+end

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

@@ -0,0 +1,109 @@
+require 'rubygems'
+require 'open3'
+require 'base64'
+require 'thor'
+
+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
+  class InvalidPassword < StandardError
+    def message
+      "Invalid password"
+    end
+  end
+  class RobotArmy::Exit < Exception
+    attr_accessor :status
+
+    def initialize(status=0)
+      @status = status
+    end
+  end
+  class RobotArmy::ShellCommandError < RuntimeError
+    attr_reader :command, :exitstatus, :output
+
+    def initialize(command, exitstatus, output)
+      @command, @exitstatus, @output = command, exitstatus, output
+      super "command failed with exit status #{exitstatus}: #{command}"
+    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
+
+  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 || $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/connection.rb

@@ -0,0 +1,174 @@
+class RobotArmy::Connection
+  attr_reader :host, :user, :password, :messenger
+  
+  def initialize(host, user=nil, password=nil)
+    @host = host
+    @user = user
+    @password = password
+    @closed = true
+  end
+  
+  def loader
+    @loader ||= RobotArmy::Loader.new
+  end
+  
+  def open(&block)
+    start_child if closed?
+    @closed = false
+    unless block_given?
+      return self
+    else
+      begin
+        return yield(self)
+      ensure
+        close unless closed?
+      end
+    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(%(|))))"}
+      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'
+          $stderr.puts "Error trying to execute: #{ruby.gsub(/^/, '  ')}\n"
+          raise response[:data]
+        when 'ok'
+          # yay! established connection
+        end
+      else
+        # try to get stderr
+        begin
+          require 'timeout'
+          err = timeout(1){ "process stderr: #{stderr.read}" }
+        rescue Timeout::Error
+          err = 'additionally, failed to get stderr'
+        end
+      
+        raise "Failed to start remote ruby process. #{err}"
+      end
+    
+      ##
+      ## finish up
+      ##
+    
+      @closed = false
+    rescue Object => e
+      $stderr.puts "Failed to establish connection to #{host}: #{e.message}"
+      raise e
+    ensure
+      @closed = true
+    end
+  end
+  
+  def info
+    post(:command => :info)
+    handle_response(get)
+  end
+  
+  def get
+    messenger.get
+  end
+  
+  def post(*args)
+    messenger.post(*args)
+  end
+  
+  def closed?
+    @closed
+  end
+  
+  def close
+    raise RobotArmy::ConnectionNotOpen if closed?
+    messenger.post(:command => :exit)
+    @closed = true
+  end
+  
+  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/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