robot-army 0.1.8

data/spec/soldier_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RobotArmy::Soldier do
+  before do
+    # given
+    @messenger = mock(:messenger)
+    @soldier = RobotArmy::Soldier.new(@messenger)
+  end
+  
+  it "can accept eval commands" do
+    # then
+    @soldier.run(:eval, :code => '3+4', :file => __FILE__, :line => __LINE__).
+      should == 7
+    
+    # and
+    @soldier.run(:eval, :code => 'Time.now', :file => __FILE__, :line => __LINE__).
+      should be_an_instance_of(Time)
+  end
+  
+  it "evaluates each command in the same process" do
+    # when
+    pid = proc{ @soldier.run(:eval, :code => 'Process.pid', :file => __FILE__, :line => __LINE__) }
+    
+    # then
+    pid.call.should == pid.call
+  end
+  
+  it "raises on unrecognized commands" do
+    proc{ @soldier.run(:foo, nil) }.should raise_error(ArgumentError)
+  end
+  
+  it "listens for commands from the messenger to run" do
+    # then
+    @soldier.should_receive(:run).with(:eval, :code => 'Hash.new')
+    
+    # when
+    @messenger.stub!(:post)
+    @messenger.stub!(:get).and_return(:command => :eval, :data => {:code => 'Hash.new'})
+    @soldier.listen
+  end
+  
+  it "posts through the messenger the result of commands run by listening" do
+    # then
+    @messenger.should_receive(:post).with(:status => 'ok', :data => 1)
+    
+    # when
+    @messenger.stub!(:get).and_return(:command => :eval, :data => {:code => '1'})
+    @soldier.stub!(:run).and_return(1)
+    @soldier.listen
+  end
+  
+  it "posts back and raises RobotArmy::Exit when running the exit command" do
+    @messenger.should_receive(:post).with(:status => 'ok')
+    proc{ @soldier.run(:exit, nil) }.should raise_error(RobotArmy::Exit)
+  end
+  
+  it "returns the pid and type when asked for info" do
+    @soldier.run(:info, nil).should == {:pid => Process.pid, :type => 'RobotArmy::Soldier'}
+  end
+  
+  it "posts back a warning if the :eval return value is not marshalable" do
+    # then
+    @messenger.should_receive(:post).
+      with(:status => 'warning', :data => "ignoring invalid remote return value #{$stdin.inspect}")
+    
+    # when
+    @messenger.stub!(:get).and_return(
+      :command => :eval, :data => {:code => '$stdin', :file => __FILE__, :line => __LINE__})
+    @soldier.listen
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$TESTING=true
+load File.join(File.dirname(__FILE__), '..', 'lib', 'robot-army.rb')
+
+Spec::Runner.configure do |config|
+  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 silence capture
+end

data/spec/task_master_spec.rb

@@ -0,0 +1,306 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Example < RobotArmy::TaskMaster
+  hosts %[www1.example.com www2.example.com]
+end
+
+class Localhost < RobotArmy::TaskMaster
+  host :localhost
+end
+
+describe RobotArmy::TaskMaster, 'host management' do
+  before do
+    @example = Example.new
+  end
+
+  it "allows setting a single host" do
+    Example.host 'example.com'
+    Example.host.should == 'example.com'
+  end
+
+  it "allows accessing multi-hosts when using the single-host interface" do
+    Example.host 'example.com'
+    Example.hosts.should == %w[example.com]
+  end
+
+  it "allows setting multiple hosts on the class" do
+    Example.hosts %w[example.com test.com]
+    Example.hosts.should == %w[example.com test.com]
+  end
+
+  it "denies accessing a single host when using the multi-host interface" do
+    Example.hosts %w[example.com test.com]
+    proc { Example.host }.should raise_error(
+      RobotArmy::HostArityError, "There are 2 hosts, so calling host doesn't make sense")
+  end
+
+  it "instances default to the hosts set on the class" do
+    Example.host 'example.com'
+    @example.host.should == 'example.com'
+
+    Example.hosts %w[example.com test.com]
+    @example.hosts.should == %w[example.com test.com]
+  end
+
+  it "allows setting a single host on an instance" do
+    @example.host = 'example.com'
+    @example.host.should == 'example.com'
+  end
+
+  it "allows accessing multi-hosts when using the single-host interface on instances" do
+    @example.host = 'example.com'
+    @example.hosts.should == %w[example.com]
+  end
+
+  it "allows setting multiple hosts on an instance" do
+    @example.hosts = %w[example.com test.com]
+    @example.hosts.should == %w[example.com test.com]
+  end
+
+  it "denies accessing a single host when using the multi-host interface" do
+    @example.hosts = %w[example.com test.com test2.com]
+    proc { @example.host }.should raise_error(
+      RobotArmy::HostArityError, "There are 3 hosts, so calling host doesn't make sense")
+  end
+end
+
+describe RobotArmy::TaskMaster, 'remote' do
+  before do
+    @localhost = Localhost.new
+    @example   = Example.new
+  end
+
+  it "returns a single item when using the single-host interface" do
+    @localhost.stub!(:remote_eval).and_return(7)
+    @localhost.remote { 3+4 }.should == 7
+  end
+
+  it "returns an array of items when using the multi-host interface" do
+    @example.stub!(:remote_eval).and_return(7)
+    @example.remote { 3+4 }.should == [7, 7]
+  end
+end
+
+describe RobotArmy::TaskMaster do
+  before do
+    @localhost = Localhost.new
+    @example = Example.new
+  end
+
+  it "runs a remote block on each host" do
+    @example.should_receive(:remote_eval).exactly(2).times
+    @example.remote { 3+4 }
+  end
+
+
+  it "can execute a Ruby block and return the result" do
+    @localhost.remote { 3+4 }.should == 7
+  end
+
+  it "executes its block in a different process" do
+    @localhost.remote { Process.pid }.should_not == Process.pid
+  end
+
+  it "preserves local variables" do
+    a = 42
+    @localhost.remote { a }.should == 42
+  end
+
+  it "warns about invalid remote return values" do
+    capture(:stderr) { @localhost.remote { $stdin } }.
+      should =~ /WARNING: ignoring invalid remote return value/
+  end
+
+  it "returns nil if the remote return value is invalid" do
+    silence(:stderr) { @localhost.remote { $stdin }.should be_nil }
+  end
+
+  it "re-raises exceptions thrown remotely" do
+    proc { @localhost.remote { raise ArgumentError, "You fool!" } }.
+      should raise_error(ArgumentError)
+  end
+
+  it "prints the child Ruby's stderr to stderr" do
+    pending('we may not want to do this, even')
+    capture(:stderr) { @localhost.remote { $stderr.print "foo" } }.should == "foo"
+  end
+
+  it "runs multiple remote blocks for the same host in different processes" do
+    @localhost.remote { $a = 1 }
+    @localhost.remote { $a }.should be_nil
+  end
+
+  it "only loads one Officer process on the remote machine" do
+    info = @localhost.connection(@localhost.host).info
+    info[:pid].should_not == Process.pid
+    info[:type].should == 'RobotArmy::Officer'
+    @localhost.connection(@localhost.host).info.should == info
+  end
+
+  it "runs as a normal (non-super) user by default" do
+    @localhost.remote{ Process.uid }.should_not == 0
+  end
+
+  it "loads dependencies" do
+    @localhost.dependency "thor"
+    @localhost.remote { Thor ; 45 }.should == 45 # loading should not bail here
+  end
+
+  it "delegates scp to the scp binary" do
+    @localhost.should_receive(:`).with('scp -q file.tgz example.com:/tmp 2>&1')
+    @localhost.host = 'example.com'
+    @localhost.scp 'file.tgz', '/tmp'
+  end
+
+  it "delegates to scp without a host when host is localhost" do
+    @localhost.should_receive(:`).with('scp -q file.tgz /tmp 2>&1')
+    @localhost.scp 'file.tgz', '/tmp'
+  end
+end
+
+describe RobotArmy::TaskMaster, 'scp' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "raises if scp fails due to a permissions error" do
+    @localhost.stub!(:`).and_return("scp: /tmp/foo: Permission denied\n")
+    $?.stub!(:exitstatus).and_return(1)
+    lambda { @localhost.scp('foo', '/tmp') }.should raise_error(Errno::EACCES)
+  end
+
+  it "raises if scp cannot locate the source file" do
+    lambda { @localhost.scp('i-dont-exist', '/tmp') }.should raise_error(Errno::ENOENT)
+  end
+end
+
+describe RobotArmy::TaskMaster, 'sh' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "raises exceptions on failed commands" do
+    lambda {
+      @localhost.remote { sh 'which this-command-does-not-exist' }
+    }.should raise_error(RobotArmy::ShellCommandError)
+  end
+
+  it "does not raise exceptions on successful commands" do
+    lambda {
+      @localhost.remote { sh 'echo foo' }
+    }.should_not raise_error(RobotArmy::ShellCommandError)
+  end
+
+  it "includes stderr from failed commands" do
+    begin
+      @localhost.remote { sh 'ruby -e "STDERR.puts %{stderr message}; exit(1)"' }
+    rescue RobotArmy::ShellCommandError => e
+      e.output.should == "stderr message\n"
+    end
+  end
+
+  it "includes stdout from failed commands" do
+    begin
+      @localhost.remote { sh 'ruby -e "STDOUT.puts %{stdout message}; exit(1)"' }
+    rescue RobotArmy::ShellCommandError => e
+      e.output.should == "stdout message\n"
+    end
+  end
+end
+
+describe RobotArmy::TaskMaster, 'remote (with args)' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "can pass arguments explicitly" do
+    @localhost.remote(:args => [42]) { |a| a }.should == 42
+  end
+
+  it "shadows local variables of the same name" do
+    a = 23
+    @localhost.remote(:args => [42]) { |a| a }.should == 42
+  end
+end
+
+describe RobotArmy::TaskMaster, 'cptemp' do
+  before do
+    @localhost = Localhost.new
+    @path = 'cptemp-spec-file'
+    File.open(@path, 'w') {|f| f << 'testing'}
+  end
+
+  it "safely copies to a new temporary directory" do
+    destination = @localhost.cptemp @path
+    File.read(destination).should == 'testing'
+  end
+
+  it "yields the path to each host if a block is passed" do
+    path, pid = @localhost.cptemp(@path) { |path| [path, Process.pid] }
+    File.basename(path).should == @path
+    pid.should_not be_nil
+    pid.should_not == Process.pid
+  end
+
+  it "deletes the file on exit" do
+    destination = @localhost.cptemp @path
+    RobotArmy::AtExit.shared_instance.do_exit
+    fail "Expected cptemp'ed file to be deleted when exit callbacks were run" if File.exist?(destination)
+  end
+
+  after do
+    FileUtils.rm_f(@path)
+  end
+end
+
+describe RobotArmy::TaskMaster, 'with proxies' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "can allow remote method calls on the local object" do
+    def @localhost.foo; 'bar'; end
+    @localhost.remote { foo }.should == 'bar'
+  end
+
+  it "allows calling methods with arguments" do
+    def @localhost.echo(o) o; end
+    @localhost.remote { echo 42 }.should == 42
+  end
+
+  it "allows passing a block to method calls on proxy objects" do
+    pending('this is insane. should I do this?')
+  end
+
+  it "allows interaction with IOs" do
+    capture(:stdout) {
+      stdout = $stdout
+      @localhost.remote { stdout.puts "hey there" }
+    }.should == "hey there\n"
+  end
+
+  it "returns a proxy if the return value of an upstream call can't be marshaled" do
+    def @localhost.stdout; $stdout; end
+    capture(:stdout) { @localhost.remote { stdout.puts "foo" } }.should == "foo\n"
+  end
+end
+
+describe RobotArmy::TaskMaster, 'sudo' do
+  before do
+    @localhost = Localhost.new
+  end
+
+  it "runs remote with the root user by default" do
+    @localhost.should_receive(:remote).
+      with(@localhost.hosts, :user => 'root')
+
+    @localhost.sudo { File.read('/etc/passwd') }
+  end
+
+  it "allows specifying a particular user" do
+    @localhost.should_receive(:remote).
+      with(@localhost.hosts, :user => 'www-data')
+
+    @localhost.sudo(:user => 'www-data') { %x{/etc/init.d/apache2 restart} }
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: robot-army
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 8
+  version: 0.1.8
+platform: ruby
+authors: 
+- Brian Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 11
+        - 7
+        version: 0.11.7
+  type: :runtime
+  version_requirements: *id003
+description: Deploy using Thor by executing Ruby remotely
+email: brian@wesabe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/robot-army.rb
+- lib/robot-army/at_exit.rb
+- lib/robot-army/connection.rb
+- lib/robot-army/dependency_loader.rb
+- lib/robot-army/eval_builder.rb
+- lib/robot-army/eval_command.rb
+- lib/robot-army/gate_keeper.rb
+- lib/robot-army/io.rb
+- lib/robot-army/keychain.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/remote_evaler.rb
+- lib/robot-army/ruby2ruby_ext.rb
+- lib/robot-army/soldier.rb
+- lib/robot-army/task_master.rb
+has_rdoc: true
+homepage: http://github.com/wesabe/robot-army
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: robot-army
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Deploy using Thor by executing Ruby remotely
+test_files: 
+- spec/at_exit_spec.rb
+- spec/connection_spec.rb
+- spec/dependency_loader_spec.rb
+- spec/gate_keeper_spec.rb
+- spec/integration_spec.rb
+- spec/io_spec.rb
+- spec/keychain_spec.rb
+- spec/loader_spec.rb
+- spec/marshal_ext_spec.rb
+- spec/messenger_spec.rb
+- spec/officer_spec.rb
+- spec/proxy_spec.rb
+- spec/ruby2ruby_ext_spec.rb
+- spec/soldier_spec.rb
+- spec/spec_helper.rb
+- spec/task_master_spec.rb
+- examples/whoami.rb