rush 0.1

data/lib/rush/process.rb

@@ -0,0 +1,39 @@
+# An array of these objects is returned by Rush::Box#processes.
+class Rush::Process
+	attr_reader :box, :pid, :uid, :command, :cmdline, :mem, :cpu
+
+	# 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
+		@command = params[:command]
+		@cmdline = params[:cmdline]
+		@mem = params[:rss]
+		@cpu = params[:time]
+	end
+
+	def to_s      # :nodoc:
+		inspect
+	end
+
+	def inspect   # :nodoc:
+		"Process #{@pid}: #{@cmdline}"
+	end
+
+	# Returns true if the process is currently running.
+	def alive?
+		box.connection.process_alive(pid)
+	end
+
+	# Terminate the process.
+	def kill
+		box.connection.kill_process(pid)
+	end
+
+	def self.all
+		Rush::Box.new('localhost').processes
+	end
+end  

data/lib/rush/remote.rb

@@ -0,0 +1,105 @@
+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 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 size(full_path)
+		transmit(:action => 'size', :full_path => full_path)
+	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
+
+	class NotAuthorized < Exception; end
+	class FailedTransmit < Exception; 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)
+		tunnel.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)
+			raise NotAuthorized if res.code == "401"
+			raise FailedTransmit if res.code != "200"
+			res.body
+		end
+	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,81 @@
+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])
+			printf "%-20s", params[:action]
+			print without_action.inspect
+			print " + #{payload.size} bytes of payload" if payload.size > 0
+			puts
+
+			params[:payload] = payload
+			result = box.connection.receive(params)
+
+			response.start(200) do |head, out|
+				out.write result
+			end
+		end
+	end
+
+	def authorize(auth)
+		unless m = auth.match(/^Basic (.+)$/)
+			puts "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
+			puts "Malformed user or password"
+			return false
+		end
+
+		if password == config.passwords[user]
+			return true
+		else
+			puts "Access denied to #{user}"
+			return false
+		end
+	end
+
+	def box
+		@box ||= Rush::Box.new('localhost')
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	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
+
+		puts "rushd listening on #{host}:#{port}"
+
+		h = Mongrel::HttpServer.new(host, port)
+		h.register("/", RushHandler.new)
+		h.run.join
+	end
+end

data/lib/rush/shell.rb

@@ -0,0 +1,123 @@
+require 'readline'
+
+# Rush::Shell is used to create an interactive shell.  It is invoked by the rush binary.
+module Rush
+	class Shell
+		# 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'])
+			pwd = Rush::Dir.new(ENV['PWD'])
+
+			@pure_binding = Proc.new { }
+			$last_res = nil
+
+			@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
+
+			eval @config.load_env, @pure_binding
+
+			eval "def processes; Rush::Box.new('localhost').processes; end", @pure_binding
+
+			commands = @config.load_commands
+			Rush::Dir.class_eval commands
+			Array.class_eval commands
+		end
+
+		# Run the interactive shell using readline.
+		def run
+			loop do
+				cmd = Readline.readline('rush> ')
+
+				finish if cmd.nil?
+				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 Exception => e
+					puts "Exception #{e.class}: #{e}"
+					e.backtrace.each do |t|
+						puts "   #{::File.expand_path(t)}"
+					end
+				end
+			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)
+			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|
+					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"
+			else
+				puts "=> #{res.inspect}"
+			end
+		end
+
+		def path_parts(input)   # :nodoc:
+			input.match(/^(.+)\[(['"])([^\]]+)$/).to_a.slice(1, 3) rescue [ 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 = path_parts(input)
+				if possible_var and possible_var.match(/^[a-z0-9_]+$/)
+					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(/^#{partial_path}/)
+						end.map do |e|
+							possible_var + '[' + quote + e.name + (e.dir? ? "/" : "")
+						end
+					end
+				end
+				nil
+			end
+		end
+	end
+end

data/lib/rush/ssh_tunnel.rb

@@ -0,0 +1,113 @@
+# Internal class for managing an ssh tunnel, across which relatively insecure
+# HTTP commands can be sent by Rush::Connection::Remote.
+class Rush::SshTunnel
+	def initialize(real_host)
+		@real_host = real_host
+	end
+
+	def host
+		'localhost'
+	end
+
+	def port
+		@port
+	end
+
+	def ensure_tunnel
+		return if @port and tunnel_alive?
+
+		@port = config.tunnels[@real_host]
+
+		if !@port or !tunnel_alive?
+			setup_everything
+		end
+	end
+
+	def setup_everything
+		display "Connecting to #{@real_host}..."
+		push_credentials
+		launch_rushd
+		establish_tunnel
+	end
+
+	def push_credentials
+		display "Pushing credentials"
+		config.ensure_credentials_exist
+		ssh_append_to_credentials(config.credentials_file.contents.strip)
+	end
+
+	def ssh_append_to_credentials(string)
+		# the following horror is exactly why rush is needed
+		passwords_file = "~/.rush/passwords"
+		string = "'#{string}'"
+		ssh "M=`grep #{string} #{passwords_file} | wc -l`; if [ $M = 0 ]; then echo #{string} >> #{passwords_file}; fi"
+	end
+
+	def launch_rushd
+		display "Launching rushd"
+		ssh("if [ `ps aux | grep rushd | grep -v grep | wc -l` -ge 1 ]; then exit; fi; rushd > /dev/null 2>&1 &")
+	end
+
+	def establish_tunnel
+		display "Establishing ssh tunnel"
+		@port = next_available_port
+
+		make_ssh_tunnel
+
+		tunnels = config.tunnels
+		tunnels[@real_host] = @port
+		config.save_tunnels tunnels
+
+		sleep 0.5
+	end
+
+	def tunnel_options
+		{
+			:local_port => @port,
+			:remote_port => Rush::Config::DefaultPort,
+			:ssh_host => @real_host,
+			:stall_command => "sleep 9000"
+		}
+	end
+
+	def tunnel_alive?
+		`#{tunnel_count_command}`.to_i > 0
+	end
+
+	def tunnel_count_command
+		"ps x | grep '#{ssh_tunnel_command_without_stall}' | grep -v grep | wc -l"
+	end
+
+	class SshFailed < Exception; end
+	class NoPortSelectedYet < Exception; end
+
+	def ssh(command)
+		raise SshFailed unless system("ssh #{@real_host} '#{command}'")
+	end
+
+	def make_ssh_tunnel
+		raise SshFailed unless system(ssh_tunnel_command)
+	end
+
+	def ssh_tunnel_command_without_stall
+		options = tunnel_options
+		raise NoPortSelectedYet unless options[:local_port]
+		"ssh -f -L #{options[:local_port]}:127.0.0.1:#{options[:remote_port]} #{options[:ssh_host]}"
+	end
+
+	def ssh_tunnel_command
+		ssh_tunnel_command_without_stall + " \"#{tunnel_options[:stall_command]}\""
+	end
+
+	def next_available_port
+		(config.tunnels.values.max || Rush::Config::DefaultPort) + 1
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	end
+
+	def display(msg)
+		puts msg
+	end
+end