wesabe-robot-army 0.1

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,36 @@
+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
+------------
+
+  * 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
+  * 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/lib/robot-army/connection.rb

@@ -0,0 +1,106 @@
+class RobotArmy::Connection
+  attr_reader :host, :messenger
+  
+  def initialize(host)
+    @host = host
+    @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 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
+    
+      loader.libraries.replace $TESTING ? 
+        [File.join(File.dirname(__FILE__), '..', 'robot-army')] : %w[rubygems robot-army]
+    
+      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 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 self.localhost(&block)
+    conn = new(nil)
+    block ? conn.open(&block) : conn
+  end
+end

data/lib/robot-army/gate_keeper.rb

@@ -0,0 +1,22 @@
+class RobotArmy::GateKeeper
+  def connect(host)
+    connections[host] ||= establish_connection(host)
+  end
+  
+  def establish_connection(host)
+    connection = connections[host] = RobotArmy::Connection.new(host)
+    connection.open
+  end
+  
+  def connections
+    @connections ||= {}
+  end
+  
+  def close
+    connections.each { |host,c| c.close unless c.closed? }
+  end
+  
+  def self.shared_instance
+    @shared_instance ||= new
+  end
+end

data/lib/robot-army/loader.rb

@@ -0,0 +1,83 @@
+class RobotArmy::Loader
+  attr_accessor :messenger
+  
+  def libraries
+    @libraries ||= []
+  end
+  
+  def render
+    %{
+      begin
+        ##
+        ## setup
+        ##
+        
+        $stdout.sync = $stdin.sync = true
+        #{libraries.map{|l| "require #{l.inspect}"}.join("\n")}
+        
+        
+        ##
+        ## local Robot Army objects to communicate with the parent
+        ##
+        
+        loader = RobotArmy::Loader.new
+        loader.messenger = RobotArmy::Messenger.new($stdin, $stdout)
+        loader.messenger.post(:status => 'ok')
+        
+        ##
+        ## event loop
+        ##
+        
+        loader.load
+      rescue Object => e
+        ##
+        ## exception handler of last resort
+        ##
+        
+        if defined?(RobotArmy::Exit) && e.is_a?(RobotArmy::Exit)
+          # don't stomp on our own "let me out" exception
+          exit(e.status)
+        else
+          # if we got here that means something up to and including loader.load
+          # went unexpectedly wrong. this could be a missing library, or it 
+          # could be a bug in Robot Army. either way we should report the error
+          # back to the place we came from so that they may re-raise the exception
+          
+          # a little bit of un-DRY
+          print Base64.encode64(Marshal.dump(:status => 'error', :data => e))+'|'
+          exit(1)
+        end
+      end
+    }
+  end
+  
+  def safely
+    begin
+      return yield, true
+    rescue RobotArmy::Exit
+      # let RobotArmy::Exit through
+      raise
+    rescue Object => e
+      messenger.post(:status => 'error', :data => e)
+      return nil, false
+    end
+  end
+  
+  def safely_or_die(&block)
+    retval, success = safely(&block)
+    exit(1) unless success
+    return retval
+  end
+  
+  def load
+    # create a soldier
+    soldier = safely_or_die{ RobotArmy::Soldier.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/messenger.rb

@@ -0,0 +1,32 @@
+module RobotArmy
+  class Messenger
+    attr_reader :input, :output
+    
+    def initialize(input, output)
+      @input, @output = input, output
+    end
+    
+    def post(response)
+      debug "post(#{response.inspect})"
+      dump = Marshal.dump(response)
+      dump = Base64.encode64(dump) + '|'
+      output << dump
+    end
+    
+    def get
+      data = nil
+      loop do
+        case data = input.gets('|')
+        when nil, ''
+          return nil
+        when /^\s*$/
+          # again!
+        else
+          break
+        end
+      end
+      data = Base64.decode64(data.chop)
+      Marshal.load(data)
+    end
+  end
+end

data/lib/robot-army/officer.rb

@@ -0,0 +1,14 @@
+class RobotArmy::Officer < RobotArmy::Soldier
+  def run(command, data)
+    case command
+    when :eval
+      RobotArmy::Connection.localhost do |local|
+        local.post(:command => command, :data => data)
+      end
+    when :exit
+      super
+    else
+      super
+    end
+  end
+end

data/lib/robot-army/ruby2ruby_ext.rb

@@ -0,0 +1,24 @@
+class Proc
+  def to_ruby_with_body_flag(only_body=false)
+    ruby = to_ruby_without_body_flag
+    only_body ? "#{ruby}.call" : ruby
+  end
+  
+  alias :to_ruby_without_body_flag :to_ruby
+  alias :to_ruby :to_ruby_with_body_flag
+end
+
+class Method
+  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
+  end
+  
+  alias :to_ruby_without_body_flag :to_ruby
+  alias :to_ruby :to_ruby_with_body_flag
+end

data/lib/robot-army/soldier.rb

@@ -0,0 +1,27 @@
+class RobotArmy::Soldier
+  attr_reader :messenger
+  
+  def initialize(messenger)
+    @messenger = messenger
+  end
+  
+  def listen
+    request  = messenger.get
+    result   = run(request[:command], request[:data])
+    response = {:status => 'ok', :data => result}
+    messenger.post response
+  end
+  
+  def run(command, data)
+    case command
+    when :eval
+      instance_eval(data[:code], data[:file], data[:line])
+    when :exit
+      # tell the parent we're okay before we exit
+      messenger.post(:status => 'ok')
+      raise RobotArmy::Exit
+    else
+      raise ArgumentError, "Unrecognized command #{command.inspect}"
+    end
+  end
+end

data/lib/robot-army/task_master.rb

@@ -0,0 +1,65 @@
+module RobotArmy
+  class TaskMaster < Thor
+    def self.host(host=nil)
+      @host = host if host
+      @host
+    end
+    
+    def host
+      self.class.host
+    end
+    
+    def say(something)
+      puts "** #{something}"
+    end
+    
+    def connection
+      RobotArmy::GateKeeper.shared_instance.connect(host)
+    end
+    
+    def remote(host=self.host, &proc)
+      ##
+      ## build the code to send it
+      ##
+      
+      # fix stack traces
+      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
+      
+      code = %{
+        #{locals.join("\n")}  # all local variables
+        #{proc.to_ruby(true)} # the proc itself
+      }
+      
+      
+      ##
+      ## send the child a message
+      ##
+      
+      connection.messenger.post(:command => :eval, :data => {
+        :code => code, 
+        :file => file, 
+        :line => line
+      })
+      
+      ##
+      ## 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]}"
+      end
+    end
+  end
+end

data/lib/robot-army.rb

@@ -0,0 +1,26 @@
+%w[rubygems open3 base64 thor ruby2ruby].each do |library|
+  require library
+end
+
+module RobotArmy
+  class ConnectionNotOpen < StandardError; end
+  class RobotArmy::Exit < Exception
+    attr_accessor :status
+    
+    def initialize(status=0)
+      @status = status
+    end
+  end
+end
+
+%w[loader soldier officer messenger task_master connection gate_keeper ruby2ruby_ext].each do |file|
+  require File.join(File.dirname(__FILE__), 'robot-army', file)
+end
+
+at_exit do
+  RobotArmy::GateKeeper.shared_instance.close
+end
+
+def debug(*whatever)
+  File.open('/tmp/robot-army', 'a') { |f| f.puts "[#{Process.pid}] #{whatever.join(' ')}" }
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: wesabe-robot-army
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Brian Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: Deploy using Thor by executing Ruby remotely
+email: brian@wesabe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/robot-army
+- lib/robot-army/connection.rb
+- lib/robot-army/gate_keeper.rb
+- lib/robot-army/loader.rb
+- lib/robot-army/messenger.rb
+- lib/robot-army/officer.rb
+- lib/robot-army/ruby2ruby_ext.rb
+- lib/robot-army/soldier.rb
+- lib/robot-army/task_master.rb
+- lib/robot-army.rb
+has_rdoc: true
+homepage: http://github.com/wesabe/robot-army
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: robot-army
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Deploy using Thor by executing Ruby remotely
+test_files: []
+