aleksi-rush 0.6.6

data/lib/rush/process.rb

@@ -0,0 +1,59 @@
+# 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, :user
+
+	# params is a hash returned by the system-specific method of looking up the
+	# process list.
+	def initialize(params, box)
+		@box = box
+
+		@pid = params[:pid].to_i
+		@uid = params[:uid].to_i
+		@user = params[:user]
+		@command = params[:command]
+		@cmdline = params[:cmdline]
+		@mem = params[:mem]
+		@cpu = params[:cpu]
+		@parent_pid = params[:parent_pid]
+	end
+
+	def to_s      # :nodoc:
+		inspect
+	end
+
+	def inspect   # :nodoc:
+		if box.to_s != 'localhost'
+			"#{box} #{@pid}: #{@cmdline}"
+		else
+			"#{@pid}: #{@cmdline}"
+		end
+	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.
+	def alive?
+		box.connection.process_alive(pid)
+	end
+
+	# Terminate the process.
+	def kill(options={})
+		box.connection.kill_process(pid, options)
+	end
+
+	def ==(other)       # :nodoc:
+		pid == other.pid and box == other.box
+	end
+
+	def self.all
+		Rush::Box.new('localhost').processes
+	end
+end  

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(options={})
+		processes.each { |p| p.kill(options) }
+	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

@@ -0,0 +1,158 @@
+require 'yaml'
+
+# This class it the mirror of Rush::Connection::Local.  A Rush::Box which is
+# not localhost has a remote connection, which it can use to convert method
+# calls to text suitable for transmission across the wire.
+#
+# This is an internal class that does not need to be accessed in normal use of
+# the rush shell or library.
+class Rush::Connection::Remote
+	attr_reader :host, :tunnel
+
+	def initialize(host)
+		@host = host
+		@tunnel = Rush::SshTunnel.new(host)
+	end
+
+	def write_file(full_path, contents)
+		transmit(:action => 'write_file', :full_path => full_path, :payload => contents)
+	end
+
+	def append_to_file(full_path, contents)
+		transmit(:action => 'append_to_file', :full_path => full_path, :payload => contents)
+	end
+
+	def file_contents(full_path)
+		transmit(:action => 'file_contents', :full_path => full_path)
+	end
+
+	def destroy(full_path)
+		transmit(:action => 'destroy', :full_path => full_path)
+	end
+
+	def purge(full_path)
+		transmit(:action => 'purge', :full_path => full_path)
+	end
+
+	def create_dir(full_path)
+		transmit(:action => 'create_dir', :full_path => full_path)
+	end
+
+	def rename(path, name, new_name, force)
+		transmit(:action => 'rename', :path => path, :name => name, :new_name => new_name, :force => force)
+	end
+
+	def copy(src, dst, force)
+		transmit(:action => 'copy', :src => src, :dst => dst, :force => force)
+	end
+
+	def read_archive(full_path)
+		transmit(:action => 'read_archive', :full_path => full_path)
+	end
+
+	def write_archive(archive, dir, force)
+		transmit(:action => 'write_archive', :dir => dir, :payload => archive, :force => force)
+	end
+
+	def index(base_path, glob)
+		transmit(:action => 'index', :base_path => base_path, :glob => glob).split("\n")
+	end
+
+	def stat(full_path)
+		YAML.load(transmit(:action => 'stat', :full_path => full_path))
+	end
+
+	def set_access(full_path, access)
+		transmit access.to_hash.merge(:action => 'set_access', :full_path => full_path)
+	end
+
+	def size(full_path)
+		transmit(:action => 'size', :full_path => full_path).to_i
+	end
+
+	def processes
+		YAML.load(transmit(:action => 'processes'))
+	end
+
+	def process_alive(pid)
+		transmit(:action => 'process_alive', :pid => pid)
+	end
+
+	def kill_process(pid, options={})
+		transmit(:action => 'kill_process', :pid => pid, :payload => YAML.dump(options))
+	end
+
+	def bash(command, user, background, reset_environment)
+		transmit(:action => 'bash', :payload => command, :user => user, :background => background, :reset_environment => reset_environment)
+	end
+
+	# Given a hash of parameters (converted by the method call on the connection
+	# object), send it across the wire to the RushServer listening on the other
+	# side.  Uses http basic auth, with credentials fetched from the Rush::Config.
+	def transmit(params)
+		ensure_tunnel
+
+		require 'net/http'
+
+		payload = params.delete(:payload)
+
+		uri = "/?"
+		params.each do |key, value|
+			uri += "#{key}=#{value}&"
+		end
+
+		req = Net::HTTP::Post.new(uri)
+		req.basic_auth config.credentials_user, config.credentials_password
+
+		Net::HTTP.start(tunnel.host, tunnel.port) do |http|
+			http.read_timeout = 15*60
+			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
+	# of the result when valid.
+	def process_result(code, body)
+		raise Rush::NotAuthorized if code == "401"
+
+		if code == "400"	
+			klass, stderr, stdout = parse_exception(body)
+			raise Rush::BashFailed.new(stderr, stdout) if klass == Rush::BashFailed
+			raise klass, "#{host}:#{stderr}"
+		end
+
+		raise Rush::FailedTransmit if code != "200"
+
+		body.unpack('M').to_s.strip
+	end
+
+	# Parse an exception returned from the server, with the class name on the
+	# first line, stderr/message on the second and stdout (if any) on the third.
+	def parse_exception(body)
+		klass, stderr, stdout = body.split("\n", 3)
+		raise "invalid exception class: #{klass}" unless klass.match(/^Rush::[A-Za-z]+$/)
+		klass = Object.module_eval(klass)
+		[ klass, stderr.unpack('M').to_s.strip, stdout.unpack('M').to_s.strip ]
+	end
+
+	# Set up the tunnel if it is not already running.
+	def ensure_tunnel(options={})
+		tunnel.ensure_tunnel(options)
+	end
+
+	# Remote connections are alive when the box on the other end is responding
+	# to commands.
+	def alive?
+		index('/', 'alive_check')
+		true
+	rescue
+		false
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	end
+end

data/lib/rush/search_results.rb

@@ -0,0 +1,58 @@
+# An instance of this class is returned by Rush::Commands#search.  It contains
+# both the list of entries which matched the search, as well as the raw line
+# matches.  These methods get equivalent functionality to "grep -l" and "grep -h".
+#
+# SearchResults mixes in Rush::Commands so that you can chain multiple searches
+# or do file operations on the resulting entries.
+#
+# Examples:
+#
+#   myproj['**/*.rb'].search(/class/).entries.size
+#   myproj['**/*.rb'].search(/class/).lines.size
+#   myproj['**/*.rb'].search(/class/).copy_to other_dir
+class Rush::SearchResults
+	attr_reader :entries, :lines, :entries_with_lines, :pattern
+
+	# Make a blank container.  Track the pattern so that we can colorize the
+	# output to show what was matched.
+	def initialize(pattern)
+		# Duplication of data, but this lets us return everything in the exact
+		# order it was received.
+		@pattern = pattern
+		@entries = []
+		@entries_with_lines = {}
+		@lines = []
+	end
+
+	# Add a Rush::Entry and the array of string matches.
+	def add(entry, lines)
+		# this assumes that entry is unique
+		@entries << entry
+		@entries_with_lines[entry] = lines
+		@lines += lines
+	end
+
+	include Rush::Commands
+
+	def each(&block)
+		@entries.each(&block)
+	end
+
+	include Enumerable
+
+	def colorize(line)
+		lowlight + line.gsub(/(#{pattern.source})/, "#{hilight}\\1#{lowlight}") + normal
+	end
+
+	def hilight
+		"\e[34;1m"
+	end
+
+	def lowlight
+		"\e[37;2m"
+	end
+
+	def normal
+		"\e[0m"
+	end
+end

data/lib/rush/server.rb

@@ -0,0 +1,117 @@
+require 'rubygems'
+require 'mongrel'
+require 'base64'
+
+# Mongrel handler that translates the incoming HTTP request into a
+# Rush::Connection::Local call.  The results are sent back across the wire to
+# be decoded by Rush::Connection::Remote on the other side.
+class RushHandler < Mongrel::HttpHandler
+	def process(request, response)
+		params = {}
+		request.params['QUERY_STRING'].split("?").last.split("&").each do |tuple|
+			key, value = tuple.split("=")
+			params[key.to_sym] = value
+		end
+
+		unless authorize(request.params['HTTP_AUTHORIZATION'])
+			response.start(401) do |head, out|
+			end
+		else
+			payload = request.body.read
+
+			without_action = params.dup
+			without_action.delete(:action)
+
+			msg = sprintf "%-20s", params[:action]
+			msg += without_action.inspect
+			msg += " + #{payload.size} bytes of payload" if payload.size > 0
+			log msg
+
+			params[:payload] = payload
+
+			begin
+				result = box.connection.receive(params)
+
+				response.start(200) do |head, out|
+					out.write("#{[result].pack('M')}\n")
+				end
+			rescue Rush::Exception => e
+				response.start(400) do |head, out|
+					out.write("#{e.class}\n#{[e.stderr].pack('M')}\n#{[e.stdout].pack('M')}\n")
+				end
+			end
+		end
+	rescue Exception => e
+		log e.full_display
+	end
+
+	def authorize(auth)
+		unless m = auth.match(/^Basic (.+)$/)
+			log "Request with no authorization data"
+			return false
+		end
+
+		decoded = Base64.decode64(m[1])
+		user, password = decoded.split(':', 2)
+
+		if user.nil? or user.length == 0 or password.nil? or password.length == 0
+			log "Malformed user or password"
+			return false
+		end
+
+		if password == config.passwords[user]
+			return true
+		else
+			log "Access denied to #{user}"
+			return false
+		end
+	end
+
+	def box
+		@box ||= Rush::Box.new('localhost')
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	end
+
+	def log(msg)
+		File.open('rushd.log', 'a') do |f|
+			f.puts "#{Time.now.strftime('%Y-%m-%d %H:%I:%S')} :: #{msg}"
+		end
+	end
+end
+
+# A container class to run the Mongrel server for rushd.
+class RushServer
+	def run
+		host = "127.0.0.1"
+		port = Rush::Config::DefaultPort
+
+		rushd = RushHandler.new
+		rushd.log "rushd listening on #{host}:#{port}"
+
+		h = Mongrel::HttpServer.new(host, port)
+		h.register("/", rushd)
+		h.run.join
+	end
+end
+
+class Exception
+	def full_display
+		out = []
+		out << "Exception #{self.class} => #{self}"
+		out << "Backtrace:"
+		out << self.filtered_backtrace.collect do |t|
+			"   #{t}"
+		end
+		out << ""
+		out.join("\n")
+	end
+
+	def filtered_backtrace
+		backtrace.reject do |bt|
+			bt.match(/^\/usr\//)
+		end
+	end
+end