adamwiggins-rush 0.6.1

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,187 @@
+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:
+			case input
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)([\[\/])(['"])([^\3]*)$/
+				$~.to_a.slice(1, 4).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)(\.)(\w*)$/
+				$~.to_a.slice(1, 3).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+)$/
+				$~.to_a.slice(1, 1).push(nil).push($~.pre_match)
+			else
+				[ nil, nil, nil ]
+			end
+		end
+
+		def complete_method(receiver, dot, partial_name, pre)
+			path = eval("#{receiver}.full_path", @pure_binding) rescue nil
+			box = eval("#{receiver}.box", @pure_binding) rescue nil
+			if path and box
+				(box[path].methods - Object.methods).select do |e|
+					e.match(/^#{Regexp.escape(partial_name)}/)
+				end.map do |e|
+					(pre || '') + receiver + dot + e
+				end
+			end
+		end
+
+		def complete_path(possible_var, accessor, quote, partial_path, pre)		# :nodoc:
+			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
+				Rush::Dir.new(full_path, box).entries.select do |e|
+					e.name.match(/^#{Regexp.escape(partial_path)}/)
+				end.map do |e|
+					(pre || '') + original_var + accessor + quote + fixed_path + e.name + (e.dir? ? "/" : "")
+				end
+			end
+		end
+
+		def complete_variable(partial_name, pre)
+			lvars = eval('local_variables', @pure_binding)
+			gvars = eval('global_variables', @pure_binding)
+			ivars = eval('instance_variables', @pure_binding)
+			(lvars + gvars + ivars).select do |e|
+				e.match(/^#{Regexp.escape(partial_name)}/)
+			end.map do |e|
+				(pre || '') + e
+			end
+		end
+
+		# Try to do tab completion on dir square brackets and slash accessors.
+		#
+		# Example:
+		#
+		# dir['subd    # presing tab here will produce dir['subdir/ if subdir exists
+		# 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|
+				receiver, accessor, *rest = path_parts(input)
+				if receiver
+					case accessor
+					when /^[\[\/]$/
+						complete_path(receiver, accessor, *rest)
+					when /^\.$/
+						complete_method(receiver, accessor, *rest)
+					when nil
+						complete_variable(receiver, *rest)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/rush/ssh_tunnel.rb

@@ -0,0 +1,122 @@
+# 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(options={})
+		return if @port and tunnel_alive?
+
+		@port = config.tunnels[@real_host]
+
+		if !@port or !tunnel_alive?
+			setup_everything(options)
+		end
+	end
+
+	def setup_everything(options={})
+		display "Connecting to #{@real_host}..."
+		push_credentials
+		launch_rushd
+		establish_tunnel(options)
+	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} 2>/dev/null | wc -l`; if [ $M = 0 ]; then mkdir -p .rush; chmod 700 .rush; echo #{string} >> #{passwords_file}; chmod 600 #{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(options={})
+		display "Establishing ssh tunnel"
+		@port = next_available_port
+
+		make_ssh_tunnel(options)
+
+		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,
+		}
+	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(options={})
+		raise SshFailed unless system(ssh_tunnel_command(options))
+	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_stall_command(options={})
+		if options[:timeout] == :infinite
+			"while [ 1 ]; do sleep 1000; done"
+		elsif options[:timeout].to_i > 10
+			"sleep #{options[:timeout].to_i}"
+		else
+			"sleep 9000"
+		end
+	end
+
+	def ssh_tunnel_command(options={})
+		ssh_tunnel_command_without_stall + ' "' + ssh_stall_command(options) + '"'
+	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

data/lib/rush/string_ext.rb

@@ -0,0 +1,3 @@
+class String
+	include Rush::HeadTail
+end

data/lib/rush.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+
+# The top-level Rush module has some convenience methods for accessing the
+# local box.
+module Rush
+	# Access the root filesystem of the local box.  Example:
+	#
+	#   Rush['/etc/hosts'].contents
+	#
+	def self.[](key)
+		box[key]
+	end
+
+	# Create a dir object from the path of a provided file.  Example:
+	#
+	#   Rush.dir(__FILE__).files
+	#
+	def self.dir(filename)
+		box[::File.expand_path(::File.dirname(filename)) + '/']
+	end
+
+	# Create a dir object based on the shell's current working directory at the
+	# time the program was run.  Example:
+	#
+	#   Rush.launch_dir.files
+	#
+	def self.launch_dir
+		box[::Dir.pwd + '/']
+	end
+
+	# Run a bash command in the root of the local machine.  Equivalent to
+	# Rush::Box.new.bash.
+	def self.bash(command, options={})
+		box.bash(command, options)
+	end
+
+	# Pull the process list for the local machine.  Example:
+   #
+   #   Rush.processes.filter(:cmdline => /ruby/)
+	#
+	def self.processes
+		box.processes
+	end
+
+	# Get the process object for this program's PID.  Example:
+   #
+   #   puts "I'm using #{Rush.my_process.mem} blocks of memory"
+	#
+	def self.my_process
+		box.processes.filter(:pid => ::Process.pid).first
+	end
+
+	# Create a box object for localhost.
+	def self.box
+		@@box = Rush::Box.new
+	end
+
+	# Quote a path for use in backticks, say.
+	def self.quote(path)
+		path.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
+	end
+end
+
+module Rush::Connection; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rush/exceptions'
+require 'rush/config'
+require 'rush/commands'
+require 'rush/access'
+require 'rush/entry'
+require 'rush/file'
+require 'rush/dir'
+require 'rush/search_results'
+require 'rush/head_tail'
+require 'rush/find_by'
+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'
+require 'rush/box'
+require 'rush/embeddable_shell'

data/spec/access_spec.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Access do
+	before do
+		@access = Rush::Access.new
+	end
+
+	it "has roles: user, group, other" do
+		@access.class.roles == %w(user group other)
+	end
+
+	it "has permissions: read, write, execute" do
+		@access.class.permissions == %w(read write execute)
+	end
+
+	it "gets parts from a one-part symbol like :user" do
+		@access.parts_from(:user).should == %w(user)
+	end
+
+	it "gets parts from a two-part symbol like :read_write" do
+		@access.parts_from(:read_write).should == %w(read write)
+	end
+
+	it "allows use of 'and' in multipart symbols, like :user_and_group" do
+		@access.parts_from(:user_and_group).should == %w(user group)
+	end
+
+	it "extract_list verifies that all the parts among the valid choices" do
+		@access.should_receive(:parts_from).with(:red_green).and_return(%w(red green))
+		@access.extract_list('type', :red_green, %w(red blue green)).should == %w(red green)
+	end
+
+	it "extract_list raises a BadAccessSpecifier when there is part not in the list of choices" do
+		lambda do
+			@access.extract_list('role', :user_bork, %w(user group))
+		end.should raise_error(Rush::BadAccessSpecifier, "Unrecognized role: bork")
+	end
+
+	it "sets one value in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user))
+		@access.user_can_read.should == true
+	end
+
+	it "sets two values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+	end
+
+	it "sets four values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read write), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+		@access.user_can_write.should == true
+		@access.group_can_write.should == true
+	end
+
+	it "parse options hash" do
+		@access.parse(:user_can => :read)
+		@access.user_can_read.should == true
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.octal_permissions.should == 0400
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.user_can_write = true
+		@access.user_can_execute = true
+		@access.group_can_read = true
+		@access.group_can_execute = true
+		@access.octal_permissions.should == 0750
+	end
+
+	it "applies its settings to a file" do
+		file = "/tmp/rush_spec_#{Process.pid}"
+		begin
+			system "rm -rf #{file}; touch #{file}; chmod 770 #{file}"
+			@access.user_can_read = true
+			@access.apply(file)
+			`ls -l #{file}`.should match(/^-r--------/)
+		ensure
+			system "rm -rf #{file}; touch #{file}"
+		end
+	end
+
+	it "serializes itself to a hash" do
+		@access.user_can_read = true
+		@access.to_hash.should == {
+			:user_can_read => 1, :user_can_write => 0, :user_can_execute => 0,
+			:group_can_read => 0, :group_can_write => 0, :group_can_execute => 0,
+			:other_can_read => 0, :other_can_write => 0, :other_can_execute => 0,
+		}
+	end
+
+	it "unserializes from a hash" do
+		@access.from_hash(:user_can_read => '1')
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a serialized hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.from_hash(:user_can_read => '1').should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a parsed options hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.parse(:user_and_group_can => :read).should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "converts and octal integer into an array of integers" do
+		@access.octal_integer_array(0740).should == [ 7, 4, 0 ]
+	end
+
+	it "filters out anything above the top three digits (File.stat returns some extra data there)" do
+		@access.octal_integer_array(0100644).should == [ 6, 4, 4 ]
+	end
+
+	it "taskes permissions from an octal representation" do
+		@access.from_octal(0644)
+		@access.user_can_read.should == true
+		@access.user_can_write.should == true
+		@access.user_can_execute.should == false
+	end
+
+	it "computes a display hash by dropping false keys and converting the 1s to trues" do
+		@access.should_receive(:to_hash).and_return(:red => 1, :green => 0, :blue => 1)
+		@access.display_hash.should == { :red => true, :blue => true }
+	end
+end