rush 0.1 → 0.2

data/Rakefile

@@ -31,7 +31,7 @@ require 'rake/rdoctask'
 require 'fileutils'
 include FileUtils
 
-version = "0.1"
+version = "0.2"
 name = "rush"
 
 spec = Gem::Specification.new do |s|
@@ -45,6 +45,10 @@ spec = Gem::Specification.new do |s|
 	s.executables = [ "rush", "rushd" ]
 	s.rubyforge_project = "ruby-shell"
 
+	s.add_dependency 'mongrel'
+	s.add_dependency 'rspec'
+	s.add_dependency 'session'
+
 	s.platform = Gem::Platform::RUBY
 	s.has_rdoc = true
 	

data/lib/rush.rb

@@ -1,8 +1,11 @@
+require 'rubygems'
+
 module Rush; end
 module Rush::Connection; end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/rush')
 
+require 'exceptions'
 require 'config'
 require 'commands'
 require 'entry'
@@ -10,6 +13,7 @@ require 'file'
 require 'dir'
 require 'search_results'
 require 'head_tail'
+require 'find_by'
 require 'string_ext'
 require 'fixnum_ext'
 require 'array_ext'

data/lib/rush/array_ext.rb

@@ -13,5 +13,7 @@ class Array
 		self
 	end
 
+	include Rush::FindBy
+
 	include Rush::HeadTail
 end

data/lib/rush/box.rb

@@ -49,6 +49,25 @@ class Rush::Box
 		end
 	end
 
+	# Execute a command in the standard unix shell.  Until the day when it's no
+	# longer needed...
+	def bash(command)
+		connection.bash(command)
+	end
+
+	# Returns true if the box is responding to commands.
+	def alive?
+		connection.alive?
+	end
+
+	# This is called automatically the first time an action is invoked, but you
+	# may wish to call it manually ahead of time in order to have the tunnel
+	# already set up and running.  You can also use this to pass a timeout option,
+	# either :timeout => (seconds) or :timeout => :infinite.
+	def establish_connection(options={})
+		connection.ensure_tunnel(options)
+	end
+
 	def connection         # :nodoc:
 		@connection ||= make_connection
 	end

data/lib/rush/dir.rb

@@ -118,11 +118,21 @@ class Rush::Dir < Rush::Entry
 		end
 	end
 
+	# Run a bash command starting in this directory.
+	def bash(command)
+		box.bash "cd #{full_path} && #{command}"
+	end
+
+	# Destroy all of the contents of the directory, leaving it fresh and clean.
+	def purge
+		connection.purge full_path
+	end
+
 	# Text output of dir listing, equivalent to the regular unix shell's ls command.
 	def ls
 		out = [ "#{self}" ]
 		nonhidden_dirs.each do |dir|
-			out << "  #{dir.name}+"
+			out << "  #{dir.name}/"
 		end
 		nonhidden_files.each do |file|
 			out << "  #{file.name}"
@@ -132,12 +142,12 @@ class Rush::Dir < Rush::Entry
 
 	# Run rake within this dir.
 	def rake(*args)
-		system "cd #{full_path}; rake #{args.join(' ')}"
+		bash "rake #{args.join(' ')}"
 	end
 
 	# Run git within this dir.
 	def git(*args)
-		system "cd #{full_path}; git #{args.join(' ')}"
+		bash "git #{args.join(' ')}"
 	end
 
 	include Rush::Commands

data/lib/rush/entry.rb

@@ -48,6 +48,14 @@ class Rush::Entry
 		"#{@path}/#{@name}"
 	end
 
+	# Return true if the entry currently exists on the filesystem of the box.
+	def exists?
+		stat
+		true
+	rescue Rush::DoesNotExist
+		false
+	end
+
 	# Timestamp of entry creation.
 	def created_at
 		stat[:ctime]
@@ -69,9 +77,6 @@ class Rush::Entry
 	# Do not use rename or duplicate with a slash; use copy_to or move_to instead.
 	class NameCannotContainSlash < Exception; end
 
-	# You cannot move or copy entries to a path that is not a dir.
-	class NotADir < Exception; end
-
 	# Rename an entry to another name within the same dir.  The object's name
 	# will be updated to match the change on the filesystem.
 	def rename(new_name)

data/lib/rush/exceptions.rb

@@ -0,0 +1,26 @@
+module Rush
+	# Base class for all rush exceptions.
+	class Exception < ::Exception; 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.
+	class FailedTransmit < Exception; end
+
+	# The entry (file or dir) referenced does not exist.  Message is the entry's full path.
+	class DoesNotExist < Exception; end
+
+	# The bash command had a non-zero return value.  Message is stderr.
+	class BashFailed < Exception; end
+
+	# There's already an entry by the given name in the given dir.
+	class NameAlreadyExists < Exception; end
+
+	# The name cannot contain a slash; use two operations, rename and then move, instead.
+	class NameCannotContainSlash < Exception; end
+
+	# You cannot move or copy entries to a path that is not a dir (should end with trailing slash).
+	class NotADir < Exception; end
+end

data/lib/rush/file.rb

@@ -52,7 +52,9 @@ class Rush::File < Rush::Entry
 
 	# Return the file's contents, or if it doesn't exist, a blank string.
 	def contents_or_blank
-		contents rescue ""
+		contents
+	rescue Rush::DoesNotExist
+		""
 	end
 
 	# Count the number of lines in the file.
@@ -62,7 +64,9 @@ class Rush::File < Rush::Entry
 
 	# Return an array of lines, or an empty array if the file does not exist.
 	def lines_or_empty
-		lines rescue []
+		lines
+	rescue Rush::DoesNotExist
+		[]
 	end
 
 	include Rush::Commands

data/lib/rush/find_by.rb

@@ -0,0 +1,37 @@
+# Generic find_by (returns first match) and find_all_by (returns all matches)
+# against arrays.
+#
+# Examples:
+#
+#   processes.find_by_pid(::Process.pid)
+#   processes.find_all_by_cmdline(/mongrel_rails/)
+#
+module Rush::FindBy
+	def method_missing(meth, *args)
+		if m = meth.to_s.match(/^find_by_([a-z_]+)$/)
+			find_by(m[1], args.first)
+		elsif m = meth.to_s.match(/^find_all_by_([a-z_]+)$/)
+			find_all_by(m[1], args.first)
+		end
+	end
+
+	def find_by(field, arg)
+		detect do |item|
+			item.respond_to?(field) and compare_or_match(item.send(field), arg)
+		end
+	end
+
+	def find_all_by(field, arg)
+		select do |item|
+			item.respond_to?(field) and compare_or_match(item.send(field), arg)
+		end
+	end
+
+	def compare_or_match(value, against)
+		if against.class == Regexp
+			value.match(against) ? true : false
+		else
+			value == against
+		end
+	end
+end

data/lib/rush/local.rb

@@ -24,6 +24,8 @@ class Rush::Connection::Local
 	# Read raw bytes from a file.
 	def file_contents(full_path)
 		::File.read(full_path)
+	rescue Errno::ENOENT
+		raise Rush::DoesNotExist, full_path
 	end
 
 	# Destroy a file or dir.
@@ -33,22 +35,28 @@ class Rush::Connection::Local
 		true
 	end
 
+	# Purge the contents of a dir.
+	def purge(full_path)
+		raise "No." if full_path == '/'
+		Dir.chdir(full_path) do
+			all = Dir.glob("*", File::FNM_DOTMATCH).reject { |f| f == '.' or f == '..' }
+			FileUtils.rm_rf all
+		end
+		true
+	end
+
 	# Create a dir.
 	def create_dir(full_path)
 		FileUtils.mkdir_p(full_path)
 		true
 	end
 
-	class NameAlreadyExists < Exception; end
-	class NameCannotContainSlash < Exception; end
-	class NotADir < Exception; end
-
 	# Rename an entry within a dir.
 	def rename(path, name, new_name)
-		raise NameCannotContainSlash if new_name.match(/\//)
+		raise(Rush::NameCannotContainSlash, "#{path} rename #{name} to #{new_name}") if new_name.match(/\//)
 		old_full_path = "#{path}/#{name}"
 		new_full_path = "#{path}/#{new_name}"
-		raise NameAlreadyExists if ::File.exists?(new_full_path)
+		raise(Rush::NameAlreadyExists, "#{path} rename #{name} to #{new_name}") if ::File.exists?(new_full_path)
 		FileUtils.mv(old_full_path, new_full_path)
 		true
 	end
@@ -57,6 +65,10 @@ class Rush::Connection::Local
 	def copy(src, dst)
 		FileUtils.cp_r(src, dst)
 		true
+	rescue Errno::ENOENT
+		raise Rush::DoesNotExist, File.dirname(dst)
+	rescue RuntimeError
+		raise Rush::DoesNotExist, src
 	end
 
 	# Create an in-memory archive (tgz) of a file or dir, which can be
@@ -89,7 +101,9 @@ class Rush::Connection::Local
 				end
 			end
 		end
-		dirs + files
+		dirs.sort + files.sort
+	rescue Errno::ENOENT
+		raise Rush::DoesNotExist, base_path
 	end
 
 	# Fetch stats (size, ctime, etc) on an entry.  Size will not be accurate for dirs.
@@ -101,6 +115,8 @@ class Rush::Connection::Local
 			:atime => s.atime,
 			:mtime => s.mtime,
 		}
+	rescue Errno::ENOENT
+		raise Rush::DoesNotExist, full_path
 	end
 
 	# Fetch the size of a dir, since a standard file stat does not include the
@@ -113,6 +129,8 @@ class Rush::Connection::Local
 	def processes
 		if ::File.directory? "/proc"
 			linux_processes
+		elsif ::File.directory? "C:/WINDOWS"
+			windows_processes
 		else
 			os_x_processes
 		end
@@ -139,6 +157,7 @@ class Rush::Connection::Local
 		pid = data[0]
 		command = data[1].match(/^\((.*)\)$/)[1]
 		cmdline = ::File.read("/proc/#{pid}/cmdline").gsub(/\0/, ' ')
+		parent_pid = data[3].to_i
 		utime = data[13].to_i
 		ktime = data[14].to_i
 		vss = data[22].to_i / 1024
@@ -150,6 +169,7 @@ class Rush::Connection::Local
 			:uid => uid,
 			:command => command,
 			:cmdline => cmdline,
+			:parent_pid => parent_pid,
 			:mem => rss,
 			:cpu => time,
 		}
@@ -165,31 +185,85 @@ class Rush::Connection::Local
 
 	# ps command used to generate list of processes on non-/proc unixes.
 	def os_x_raw_ps
-		`COLUMNS=9999 ps ax -o "pid uid rss cpu command"`
+		`COLUMNS=9999 ps ax -o "pid uid ppid rss cpu command"`
 	end
 
 	# Parse a single line of the ps command and return the values in a hash
 	# suitable for use in the Rush::Process#new.
 	def parse_ps(line)
-		m = line.split(" ", 5)
+		m = line.split(" ", 6)
 		params = {}
 		params[:pid] = m[0]
 		params[:uid] = m[1]
-		params[:rss] = m[2]
-		params[:cpu] = m[3]
-		params[:cmdline] = m[4]
+		params[:parent_pid] = m[2].to_i
+		params[:mem] = m[3].to_i
+		params[:cpu] = m[4].to_i
+		params[:cmdline] = m[5]
 		params[:command] = params[:cmdline].split(" ").first
 		params
 	end
 
+	# Process list on Windows.
+	def windows_processes
+		require 'win32ole'
+		wmi = WIN32OLE.connect("winmgmts://")
+		wmi.ExecQuery("select * from win32_process").map do |proc_info|
+			parse_oleprocinfo(proc_info)
+		end
+	end
+
+	# Parse the Windows OLE process info.
+	def parse_oleprocinfo(proc_info)
+		command = proc_info.Name
+		pid = proc_info.ProcessId
+		uid = 0
+		cmdline = proc_info.CommandLine
+		rss = proc_info.MaximumWorkingSetSize
+		time = proc_info.KernelModeTime.to_i + proc_info.UserModeTime.to_i
+
+		{
+			:pid => pid,
+			:uid => uid,
+			:command => command,
+			:cmdline => cmdline,
+			:mem => rss,
+			:cpu => time,
+		}
+	end
+
 	# Returns true if the specified pid is running.
 	def process_alive(pid)
-		`ps -p #{pid} | wc -l`.to_i >= 2
+		::Process.kill(0, pid)
+		true
+	rescue Errno::ESRCH
+		false
 	end
 
 	# Terminate a process, by pid.
 	def kill_process(pid)
-		::Process.kill('TERM', pid.to_i)
+		::Process.kill('TERM', pid)
+
+		# keep trying until it's dead (technique borrowed from god)
+		5.times do
+			return if !process_alive(pid)
+			sleep 0.5
+			::Process.kill('TERM', pid) rescue nil
+		end
+
+		::Process.kill('KILL', pid) rescue nil
+	end
+
+	def bash(command)
+		require 'session'
+
+		sh = Session::Bash.new
+		out, err = sh.execute command
+		retval = sh.status
+		sh.close!
+
+		raise(Rush::BashFailed, err) if retval != 0
+
+		out
 	end
 
 	####################################
@@ -206,6 +280,7 @@ class Rush::Connection::Local
 			when 'write_file'     then write_file(params[:full_path], params[:payload])
 			when 'file_contents'  then file_contents(params[:full_path])
 			when 'destroy'        then destroy(params[:full_path])
+			when 'purge'          then purge(params[:full_path])
 			when 'create_dir'     then create_dir(params[:full_path])
 			when 'rename'         then rename(params[:path], params[:name], params[:new_name])
 			when 'copy'           then copy(params[:src], params[:dst])
@@ -216,9 +291,19 @@ class Rush::Connection::Local
 			when 'size'           then size(params[:full_path])
 			when 'processes'      then YAML.dump(processes)
 			when 'process_alive'  then process_alive(params[:pid]) ? '1' : '0'
-			when 'kill_process'   then kill_process(params[:pid])
+			when 'kill_process'   then kill_process(params[:pid].to_i)
+			when 'bash'           then bash(params[:payload])
 		else
 			raise UnknownAction
 		end
 	end
+
+	# No-op for duck typing with remote connection.
+	def ensure_tunnel(options={})
+	end
+
+	# Local connections are always alive.
+	def alive?
+		true
+	end
 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, :command, :cmdline, :mem, :cpu
+	attr_reader :box, :pid, :uid, :parent_pid, :command, :cmdline, :mem, :cpu
 
 	# params is a hash returned by the system-specific method of looking up the
 	# process list.
@@ -11,8 +11,9 @@ class Rush::Process
 		@uid = params[:uid].to_i
 		@command = params[:command]
 		@cmdline = params[:cmdline]
-		@mem = params[:rss]
-		@cpu = params[:time]
+		@mem = params[:mem]
+		@cpu = params[:cpu]
+		@parent_pid = params[:parent_pid]
 	end
 
 	def to_s      # :nodoc:
@@ -20,7 +21,17 @@ class Rush::Process
 	end
 
 	def inspect   # :nodoc:
-		"Process #{@pid}: #{@cmdline}"
+		"#{box} process #{@pid}: #{@cmdline}"
+	end
+
+	# Returns the Rush::Process parent of this process.
+	def parent
+		box.processes.select { |p| p.pid == parent_pid }.first
+	end
+
+	# Returns an array of child processes owned by this process.
+	def children
+		box.processes.select { |p| p.parent_pid == pid }
 	end
 
 	# Returns true if the process is currently running.
@@ -33,6 +44,10 @@ class Rush::Process
 		box.connection.kill_process(pid)
 	end
 
+	def ==(other)       # :nodoc:
+		pid == other.pid and box == other.box
+	end
+
 	def self.all
 		Rush::Box.new('localhost').processes
 	end