dysinger-rush 0.4

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

@@ -0,0 +1,152 @@
+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 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)
+		transmit(:action => 'rename', :path => path, :name => name, :new_name => 'new_name')
+	end
+
+	def copy(src, dst)
+		transmit(:action => 'copy', :src => src, :dst => dst)
+	end
+
+	def read_archive(full_path)
+		transmit(:action => 'read_archive', :full_path => full_path)
+	end
+
+	def write_archive(archive, dir)
+		transmit(:action => 'write_archive', :dir => dir, :payload => archive)
+	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)
+		transmit(:action => 'kill_process', :pid => pid)
+	end
+
+	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
+	# 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|
+			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, message = parse_exception(body)
+			raise klass, "#{host}:#{message}"
+		end
+
+		raise Rush::FailedTransmit if code != "200"
+
+		body
+	end
+
+	# Parse an exception returned from the server, with the class name on the
+	# first line and the message on the second.
+	def parse_exception(body)
+		klass, message = body.split("\n", 2)
+		raise "invalid exception class: #{klass}" unless klass.match(/^Rush::[A-Za-z]+$/)
+		klass = Object.module_eval(klass)
+		[ klass, message.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
+			without_action.delete(params[: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
+				end
+			rescue Rush::Exception => e
+				response.start(400) do |head, out|
+					out.write "#{e.class}\n#{e.message}\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

data/lib/rush/shell.rb

@@ -0,0 +1,148 @@
+require 'readline'
+
+# Rush::Shell is used to create an interactive shell.  It is invoked by the rush binary.
+module Rush
+	class Shell
+		attr_accessor :suppress_output
+		# Set up the user's environment, including a pure binding into which
+		# env.rb and commands.rb are mixed.
+		def initialize
+			root = Rush::Dir.new('/')
+			home = Rush::Dir.new(ENV['HOME']) if ENV['HOME']
+			pwd = Rush::Dir.new(ENV['PWD']) if ENV['PWD']
+
+			@config = Rush::Config.new
+
+			@config.load_history.each do |item|
+				Readline::HISTORY.push(item)
+			end
+
+			Readline.basic_word_break_characters = ""
+			Readline.completion_append_character = nil
+			Readline.completion_proc = completion_proc
+
+			@box = Rush::Box.new
+			@pure_binding = @box.instance_eval "binding"
+			$last_res = nil
+
+			eval @config.load_env, @pure_binding
+
+			commands = @config.load_commands
+			Rush::Dir.class_eval commands
+			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
+				cmd = Readline.readline('rush> ')
+
+				finish if cmd.nil? or cmd == 'exit'
+				next if cmd == ""
+				Readline::HISTORY.push(cmd)
+
+				execute(cmd)
+			end
+		end
+
+		# Save history to ~/.rush/history when the shell exists.
+		def finish
+			@config.save_history(Readline::HISTORY.to_a)
+			puts
+			exit
+		end
+
+		# Nice printing of different return types, particularly Rush::SearchResults.
+		def print_result(res)
+			return if self.suppress_output
+			if res.kind_of? String
+				puts res
+			elsif res.kind_of? Rush::SearchResults
+				widest = res.entries.map { |k| k.full_path.length }.max
+				res.entries_with_lines.each do |entry, lines|
+					print entry.full_path
+					print ' ' * (widest - entry.full_path.length + 2)
+					print "=> "
+					print res.colorize(lines.first.strip.head(30))
+					print "..." if lines.first.strip.length > 30
+					if lines.size > 1
+						print " (plus #{lines.size - 1} more matches)"
+					end
+					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
+		end
+
+		def path_parts(input)   # :nodoc:
+			input.match(/(\w+(?:\[[^\]]+\])*)\[(['"])([^\]]+)$/)
+			$~.to_a.slice(1, 3).push($~.pre_match)
+		rescue
+			[ nil, nil, nil, nil ]
+		end
+
+		# Try to do tab completion on dir square brackets accessors.
+		#
+		# Example:
+		#
+		# dir['subd    # presing tab here will produce dir['subdir/ if subdir exists
+		#
+		# This isn't that cool yet, because it can't do multiple levels of subdirs.
+		# It does work remotely, though, which is pretty sweet.
+		def completion_proc
+			proc do |input|
+				possible_var, quote, partial_path, pre = path_parts(input)
+				if possible_var
+					original_var, fixed_path = possible_var, ''
+					if /^(.+\/)([^\/]+)$/ === partial_path
+						fixed_path, partial_path = $~.captures
+						possible_var += "['#{fixed_path}']"
+					end
+					full_path = eval("#{possible_var}.full_path", @pure_binding) rescue nil
+					box = eval("#{possible_var}.box", @pure_binding) rescue nil
+					if full_path and box
+						dir = Rush::Dir.new(full_path, box)
+						return dir.entries.select do |e|
+							e.name.match(/^#{Regexp.escape(partial_path)}/)
+						end.map do |e|
+							(pre || '') + original_var + '[' + quote + fixed_path + e.name + (e.dir? ? "/" : "")
+						end
+					end
+				end
+				nil
+			end
+		end
+	end
+end