rush 0.3 → 0.4

data/Rakefile

@@ -31,7 +31,7 @@ require 'rake/rdoctask'
 require 'fileutils'
 include FileUtils
 
-version = "0.3"
+version = "0.4"
 name = "rush"
 
 spec = Gem::Specification.new do |s|

data/bin/rush

@@ -3,5 +3,11 @@
 require File.dirname(__FILE__) + '/../lib/rush'
 require File.dirname(__FILE__) + '/../lib/rush/shell'
 
-Rush::Shell.new.run
+shell = Rush::Shell.new
+
+if ARGV.size > 0
+	shell.execute ARGV.join(' ')
+else
+	shell.run
+end
 

data/lib/rush.rb

@@ -19,6 +19,7 @@ require 'rush/string_ext'
 require 'rush/fixnum_ext'
 require 'rush/array_ext'
 require 'rush/process'
+require 'rush/process_set'
 require 'rush/local'
 require 'rush/remote'
 require 'rush/ssh_tunnel'

data/lib/rush/box.rb

@@ -41,26 +41,39 @@ class Rush::Box
 		filesystem[key]
 	end
 
-	# Get the list of processes currently running on the box.  Returns an array
-	# of Rush::Process.
+	# Get the list of processes running on the box, not unlike "ps aux" in bash.
+	# Returns a Rush::ProcessSet.
 	def processes
-		connection.processes.map do |ps|
-			Rush::Process.new(ps, self)
-		end
+		Rush::ProcessSet.new(
+			connection.processes.map do |ps|
+				Rush::Process.new(ps, self)
+			end
+		)
 	end
 
-	# Execute a command in the standard unix shell.  Options:
+	# Execute a command in the standard unix shell.  Returns the contents of
+	# stdout if successful, or raises Rush::BashFailed with the output of stderr
+	# if the shell returned a non-zero value.  Options:
 	#
 	# :user => unix username to become via sudo
 	# :env => hash of environment variables
+	# :background => run in the background (returns Rush::Process instead of stdout)
 	#
-	# Example:
+	# Examples:
 	#
 	#   box.bash '/etc/init.d/mysql restart', :user => 'root'
 	#   box.bash 'rake db:migrate', :user => 'www', :env => { :RAILS_ENV => 'production' }
+	#   box.bash 'mongrel_rails start', :background => true
 	#
 	def bash(command, options={})
-		connection.bash(command_with_environment(command, options[:env]), options[:user])
+		cmd_with_env = command_with_environment(command, options[:env])
+
+		if options[:background]
+			pid = connection.bash(cmd_with_env, options[:user], true)
+			processes.find_by_pid(pid)
+		else
+			connection.bash(cmd_with_env, options[:user], false)
+		end
 	end
 
 	def command_with_environment(command, env)   # :nodoc:

data/lib/rush/exceptions.rb

@@ -1,12 +1,14 @@
 module Rush
 	# Base class for all rush exceptions.
-	class Exception < ::Exception; end
+	class Exception < ::RuntimeError; end
 
 	# Client was not authorized by remote server; check credentials.
 	class NotAuthorized < Exception; end
 
-	# Failed to transmit to the remote server; check if the ssh tunnel is alive,
-	# and rushd is listening on the other end.
+	# rushd is not running on the remote box.
+	class RushdNotRunning < Exception; end
+
+	# An unrecognized status code was returned by rushd.
 	class FailedTransmit < Exception; end
 
 	# The entry (file or dir) referenced does not exist.  Message is the entry's full path.

data/lib/rush/local.rb

@@ -133,7 +133,7 @@ class Rush::Connection::Local
 	# Get the list of processes as an array of hashes.
 	def processes
 		if ::File.directory? "/proc"
-			linux_processes
+			resolve_unix_uids(linux_processes)
 		elsif ::File.directory? "C:/WINDOWS"
 			windows_processes
 		else
@@ -154,6 +154,33 @@ class Rush::Connection::Local
 		list
 	end
 
+	def resolve_unix_uids(list)
+		@uid_map = {} # reset the cache between uid resolutions.
+		list.each do |process|
+			process[:user] = resolve_unix_uid_to_user(process[:uid])
+		end
+		list
+	end
+
+	# resolve uid to user
+	def resolve_unix_uid_to_user(uid)
+		require 'etc'
+
+		@uid_map ||= {}
+		uid = uid.to_i
+
+		return @uid_map[uid] if !@uid_map[uid].nil?
+		
+		begin
+			record = Etc.getpwuid(uid)
+		rescue ArgumentError
+			return nil
+		end
+
+		@uid_map[uid] = record.name
+		@uid_map[uid]
+	end
+
 	# Read a single file in /proc and store the parsed values in a hash suitable
 	# for use in the Rush::Process#new.
 	def read_proc_file(file)
@@ -256,15 +283,20 @@ class Rush::Connection::Local
 		end
 
 		::Process.kill('KILL', pid) rescue nil
+
+	rescue Errno::ESRCH
+		# if it's dead, great - do nothing
 	end
 
-	def bash(command, user=nil)
+	def bash(command, user=nil, background=false)
+		return bash_background(command, user) if background
+
 		require 'session'
 
 		sh = Session::Bash.new
 
 		if user and user != ""
-			out, err = sh.execute "sudo -u #{user} bash", :stdin => command
+			out, err = sh.execute "cd /; sudo -H -u #{user} bash", :stdin => command
 		else
 			out, err = sh.execute command
 		end
@@ -277,6 +309,27 @@ class Rush::Connection::Local
 		out
 	end
 
+	def bash_background(command, user)
+		inpipe, outpipe = IO.pipe
+
+		pid = fork do
+			outpipe.write command
+			outpipe.close
+			STDIN.reopen(inpipe)
+
+			if user and user != ''
+				exec "cd /; sudo -H -u #{user} bash"
+			else
+				exec "bash"
+			end
+		end
+		outpipe.close
+
+		Process::detach pid
+
+		pid
+	end
+
 	####################################
 
 	# Raised when the action passed in by RushServer is not known.
@@ -304,7 +357,7 @@ class Rush::Connection::Local
 			when 'processes'      then YAML.dump(processes)
 			when 'process_alive'  then process_alive(params[:pid]) ? '1' : '0'
 			when 'kill_process'   then kill_process(params[:pid].to_i)
-			when 'bash'           then bash(params[:payload], params[:user])
+			when 'bash'           then bash(params[:payload], params[:user], params[:background] == 'true')
 		else
 			raise UnknownAction
 		end

data/lib/rush/process.rb

@@ -1,6 +1,6 @@
 # An array of these objects is returned by Rush::Box#processes.
 class Rush::Process
-	attr_reader :box, :pid, :uid, :parent_pid, :command, :cmdline, :mem, :cpu
+	attr_reader :box, :pid, :uid, :parent_pid, :command, :cmdline, :mem, :cpu, :user
 
 	# params is a hash returned by the system-specific method of looking up the
 	# process list.
@@ -9,6 +9,7 @@ class Rush::Process
 
 		@pid = params[:pid].to_i
 		@uid = params[:uid].to_i
+		@user = params[:user]
 		@command = params[:command]
 		@cmdline = params[:cmdline]
 		@mem = params[:mem]

data/lib/rush/process_set.rb

@@ -0,0 +1,62 @@
+# A container for processes that behaves like an array, and adds process-specific operations
+# on the entire set, like kill.
+#
+# Example:
+#
+#   processes.filter(:cmdline => /mongrel_rails/).kill
+#
+class Rush::ProcessSet
+	attr_reader :processes
+
+	def initialize(processes)
+		@processes = processes
+	end
+
+	# Filter by any field that the process responds to.  Specify an exact value,
+	# or a regular expression.  All conditions are put together as a boolean
+	# AND, so these two statements are equivalent:
+	#
+	#   processes.filter(:uid => 501).filter(:cmdline => /ruby/)
+	#   processes.filter(:uid => 501, :cmdline => /ruby/)
+	#
+	def filter(conditions)
+		Rush::ProcessSet.new(
+			processes.select do |p|
+				conditions.all? do |key, value|
+					value.class == Regexp ?
+						value.match(p.send(key)) :
+						p.send(key) == value
+				end
+			end
+		)
+	end
+
+	# Kill all processes in the set.
+	def kill
+		processes.each { |p| p.kill }
+	end
+
+	# Check status of all processes in the set, returns an array of booleans.
+	def alive?
+		processes.map { |p| p.alive? }
+	end
+
+	include Enumerable
+
+	def each
+		processes.each { |p| yield p }
+	end
+
+	def ==(other)
+		if other.class == self.class
+			other.processes == processes
+		else
+			to_a == other
+		end
+	end
+
+	# All other messages (like size or first) are passed through to the array.
+	def method_missing(meth, *args)
+		processes.send(meth, *args)
+	end
+end

data/lib/rush/remote.rb

@@ -63,7 +63,7 @@ class Rush::Connection::Remote
 	end
 
 	def size(full_path)
-		transmit(:action => 'size', :full_path => full_path)
+		transmit(:action => 'size', :full_path => full_path).to_i
 	end
 
 	def processes
@@ -78,8 +78,8 @@ class Rush::Connection::Remote
 		transmit(:action => 'kill_process', :pid => pid)
 	end
 
-	def bash(command, user)
-		transmit(:action => 'bash', :payload => command, :user => user)
+	def bash(command, user, background)
+		transmit(:action => 'bash', :payload => command, :user => user, :background => background)
 	end
 
 	# Given a hash of parameters (converted by the method call on the connection
@@ -104,6 +104,8 @@ class Rush::Connection::Remote
 			res = http.request(req, payload)
 			process_result(res.code, res.body)
 		end
+	rescue EOFError
+		raise Rush::RushdNotRunning
 	end
 
 	# Take the http result of a transmit and raise an error, or return the body

data/lib/rush/shell.rb

@@ -31,6 +31,21 @@ module Rush
 			Array.class_eval commands
 		end
 
+		# Run a single command.
+		def execute(cmd)
+			res = eval(cmd, @pure_binding)
+			$last_res = res
+			eval("_ = $last_res", @pure_binding)
+			print_result res
+		rescue Rush::Exception => e
+			puts "Exception #{e.class} -> #{e.message}"
+		rescue ::Exception => e
+			puts "Exception #{e.class} -> #{e.message}"
+			e.backtrace.each do |t|
+				puts "   #{::File.expand_path(t)}"
+			end
+		end
+
 		# Run the interactive shell using readline.
 		def run
 			loop do
@@ -40,19 +55,7 @@ module Rush
 				next if cmd == ""
 				Readline::HISTORY.push(cmd)
 
-				begin
-					res = eval(cmd, @pure_binding)
-					$last_res = res
-					eval("_ = $last_res", @pure_binding)
-					print_result res
-				rescue Rush::Exception => e
-					puts "Exception #{e.class} -> #{e.message}"
-				rescue ::Exception => e
-					puts "Exception #{e.class} -> #{e.message}"
-					e.backtrace.each do |t|
-						puts "   #{::File.expand_path(t)}"
-					end
-				end
+				execute(cmd)
 			end
 		end
 
@@ -67,10 +70,6 @@ module Rush
 		def print_result(res)
 			if res.kind_of? String
 				puts res
-			elsif res.kind_of? Array
-				res.each do |item|
-					puts item
-				end
 			elsif res.kind_of? Rush::SearchResults
 				widest = res.entries.map { |k| k.full_path.length }.max
 				res.entries_with_lines.each do |entry, lines|
@@ -85,6 +84,21 @@ module Rush
 					print "\n"
 				end
 				puts "#{res.entries.size} matching files with #{res.lines.size} matching lines"
+			elsif res.respond_to? :each
+				counts = {}
+				res.each do |item|
+					puts item
+					counts[item.class] ||= 0
+					counts[item.class] += 1
+				end
+				if counts == {}
+					puts "=> (empty set)"
+				else
+					count_s = counts.map do |klass, count|
+						"#{count} x #{klass}"
+					end.join(', ')
+					puts "=> #{count_s}"
+				end
 			else
 				puts "=> #{res.inspect}"
 			end

data/spec/box_spec.rb

@@ -22,15 +22,21 @@ describe Rush::Box do
 	end
 
 	it "executes bash commands" do
-		@box.connection.should_receive(:bash).with('cmd', nil).and_return('output')
+		@box.connection.should_receive(:bash).with('cmd', nil, false).and_return('output')
 		@box.bash('cmd').should == 'output'
 	end
 
 	it "executes bash commands with an optional user" do
-		@box.connection.should_receive(:bash).with('cmd', 'user')
+		@box.connection.should_receive(:bash).with('cmd', 'user', false)
 		@box.bash('cmd', :user => 'user')
 	end
 
+	it "executes bash commands in the background, returning a Rush::Process" do
+		@box.connection.should_receive(:bash).with('cmd', nil, true).and_return(123)
+		@box.stub!(:processes).and_return([ mock('ps', :pid => 123) ])
+		@box.bash('cmd', :background => true).pid.should == 123
+	end
+
 	it "builds a script of environment variables to prefix the bash command" do
 		@box.command_with_environment('cmd', { :a => 'b' }).should == "export a='b'\ncmd"
 	end

data/spec/dir_spec.rb

@@ -152,8 +152,8 @@ describe Rush::Dir do
 	end
 
 	it "passes bash options (e.g., :user) through to the box bash command" do
-		@box.should_receive(:bash).with('cmd', 'options')
-		@box.bash('cmd', 'options')
+		@box.should_receive(:bash).with('cmd', :opt1 => 1, :opt2 => 2)
+		@box.bash('cmd', :opt1 => 1, :opt2 => 2)
 	end
 
 end

data/spec/local_spec.rb

@@ -95,9 +95,14 @@ describe Rush::Connection::Local do
 		@con.receive(:action => 'kill_process', :pid => '123')
 	end
 
-	it "receive -> bash" do
-		@con.should_receive(:bash).with('cmd', 'user').and_return('output')
-		@con.receive(:action => 'bash', :payload => 'cmd', :user => 'user').should == 'output'
+	it "receive -> bash (foreground)" do
+		@con.should_receive(:bash).with('cmd', 'user', false).and_return('output')
+		@con.receive(:action => 'bash', :payload => 'cmd', :user => 'user', :background => 'false').should == 'output'
+	end
+
+	it "receive -> bash (background)" do
+		@con.should_receive(:bash).with('cmd', 'user', true).and_return('output')
+		@con.receive(:action => 'bash', :payload => 'cmd', :user => 'user', :background => 'true').should == 'output'
 	end
 
 	it "receive -> unknown action exception" do
@@ -263,6 +268,11 @@ EOPS
 		@con.kill_process(123)
 	end
 
+	it "does not raise an error if the process is already dead" do
+		::Process.should_receive(:kill).and_raise(Errno::ESRCH)
+		lambda { @con.kill_process(123) }.should_not raise_error
+	end
+
 	it "executes a bash command, returning stdout when successful" do
 		@con.bash("echo test").should == "test\n"
 	end
@@ -272,7 +282,11 @@ EOPS
 	end
 
 	it "executes a bash command as another user using sudo" do
-		@con.bash("echo test2", ENV['user']).should == "test2\n"
+		@con.bash("echo test2", ENV['USER']).should == "test2\n"
+	end
+
+	it "executes a bash command in the background, returning the pid" do
+		@con.bash("true", nil, true).should > 0
 	end
 
 	it "ensure_tunnel to match with remote connection" do
@@ -282,4 +296,18 @@ EOPS
 	it "always returns true on alive?" do
 		@con.should be_alive
 	end
+
+	it "resolves a unix uid to a user" do
+		@con.resolve_unix_uid_to_user(0).should == "root"
+		@con.resolve_unix_uid_to_user('0').should == "root"
+	end
+
+	it "returns nil if the unix uid does not exist" do
+		@con.resolve_unix_uid_to_user(9999).should be_nil
+	end
+
+	it "iterates through a process list and resolves the unix uid for each" do
+		list = [ { :uid => 0, :command => 'pureftpd' }, { :uid => 9999, :command => 'defunk' } ]
+		@con.resolve_unix_uids(list).should == [ { :uid => 0, :user => 'root', :command => 'pureftpd' }, { :uid => 9999, :command => 'defunk', :user => nil } ]
+	end
 end

data/spec/process_set_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::ProcessSet do
+	before do
+		@process = mock('process')
+		@set = Rush::ProcessSet.new([ @process ])
+	end
+
+	it "is Enumerable" do
+		@set.select { |s| s == @process }.should == [ @process ]
+	end
+
+	it "defines size" do
+		@set.size.should == 1
+	end
+
+	it "defines first" do
+		@set.first.should == @process
+	end
+
+	it "is equal to sets with the same contents" do
+		@set.should == Rush::ProcessSet.new([ @process ])
+	end
+
+	it "is equal to arrays with the same contents" do
+		@set.should == [ @process ]
+	end
+
+	it "kills all processes in the set" do
+		@process.should_receive(:kill)
+		@set.kill
+	end
+
+	it "checks the alive? state of all processes in the set" do
+		@process.should_receive(:alive?).and_return(true)
+		@set.alive?.should == [ true ]
+	end
+
+	it "filters the set from a conditions hash and returns the filtered set" do
+		@process.stub!(:pid).and_return(123)
+		@set.filter(:pid => 123).first.should == @process
+		@set.filter(:pid => 456).size.should == 0
+	end
+
+	it "filters with regexps if provided in the conditions" do
+		@process.stub!(:command).and_return('foobaz')
+		@set.filter(:command => /baz/).first.should == @process
+		@set.filter(:command => /blerg/).size.should == 0
+	end
+end

data/spec/process_spec.rb

@@ -34,7 +34,7 @@ describe Rush::Process do
 	end
 
 	it "knows the executed binary" do
-		@process.command.should == "ruby"
+		@process.command.should match(/^ruby/)
 	end
 
 	it "knows the command line" do

data/spec/remote_spec.rb

@@ -73,8 +73,8 @@ describe Rush::Connection::Local do
 	end
 
 	it "transmits size" do
-		@con.should_receive(:transmit).with(:action => 'size', :full_path => 'full_path').and_return("")
-		@con.size('full_path')
+		@con.should_receive(:transmit).with(:action => 'size', :full_path => 'full_path').and_return("123")
+		@con.size('full_path').should == 123
 	end
 
 	it "transmits processes" do
@@ -93,8 +93,8 @@ describe Rush::Connection::Local do
 	end
 
 	it "transmits bash" do
-		@con.should_receive(:transmit).with(:action => 'bash', :payload => 'cmd', :user => 'user').and_return('output')
-		@con.bash('cmd', 'user').should == 'output'
+		@con.should_receive(:transmit).with(:action => 'bash', :payload => 'cmd', :user => 'user', :background => 'bg').and_return('output')
+		@con.bash('cmd', 'user', 'bg').should == 'output'
 	end
 
 	it "an http result code of 401 raises NotAuthorized" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rush
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  version: "0.4"
 platform: ruby
 authors: 
 - Adam Wiggins
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-26 00:00:00 -07:00
+date: 2008-07-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mongrel
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -32,6 +34,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: session
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -52,46 +55,48 @@ files:
 - Rakefile
 - bin/rush
 - bin/rushd
+- lib/rush.rb
 - lib/rush
-- lib/rush/access.rb
-- lib/rush/array_ext.rb
-- lib/rush/box.rb
-- lib/rush/commands.rb
 - lib/rush/config.rb
-- lib/rush/dir.rb
+- lib/rush/head_tail.rb
+- lib/rush/search_results.rb
 - lib/rush/entry.rb
-- lib/rush/exceptions.rb
-- lib/rush/file.rb
 - lib/rush/find_by.rb
-- lib/rush/fixnum_ext.rb
-- lib/rush/head_tail.rb
+- lib/rush/file.rb
 - lib/rush/local.rb
-- lib/rush/process.rb
-- lib/rush/remote.rb
-- lib/rush/search_results.rb
-- lib/rush/server.rb
-- lib/rush/shell.rb
 - lib/rush/ssh_tunnel.rb
+- lib/rush/shell.rb
+- lib/rush/server.rb
+- lib/rush/process_set.rb
+- lib/rush/array_ext.rb
+- lib/rush/remote.rb
+- lib/rush/fixnum_ext.rb
+- lib/rush/commands.rb
+- lib/rush/process.rb
+- lib/rush/dir.rb
 - lib/rush/string_ext.rb
-- lib/rush.rb
+- lib/rush/box.rb
+- lib/rush/exceptions.rb
+- lib/rush/access.rb
+- spec/remote_spec.rb
+- spec/base.rb
+- spec/ssh_tunnel_spec.rb
+- spec/local_spec.rb
 - spec/access_spec.rb
+- spec/file_spec.rb
+- spec/string_ext_spec.rb
 - spec/array_ext_spec.rb
-- spec/base.rb
-- spec/box_spec.rb
 - spec/commands_spec.rb
 - spec/config_spec.rb
-- spec/dir_spec.rb
-- spec/entry_spec.rb
-- spec/file_spec.rb
-- spec/find_by_spec.rb
 - spec/fixnum_ext_spec.rb
-- spec/local_spec.rb
-- spec/process_spec.rb
-- spec/remote_spec.rb
 - spec/search_results_spec.rb
+- spec/process_spec.rb
 - spec/shell_spec.rb
-- spec/ssh_tunnel_spec.rb
-- spec/string_ext_spec.rb
+- spec/dir_spec.rb
+- spec/entry_spec.rb
+- spec/find_by_spec.rb
+- spec/box_spec.rb
+- spec/process_set_spec.rb
 has_rdoc: true
 homepage: http://rush.heroku.com/
 post_install_message: 
@@ -114,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ruby-shell
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A Ruby replacement for bash+ssh.