rush 0.1 → 0.2

data/lib/rush/remote.rb

@@ -26,6 +26,10 @@ class Rush::Connection::Remote
 		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
@@ -70,14 +74,15 @@ class Rush::Connection::Remote
 		transmit(:action => 'kill_process', :pid => pid)
 	end
 
-	class NotAuthorized < Exception; end
-	class FailedTransmit < Exception; end
+	def bash(command)
+		transmit(:action => 'bash', :payload => command)
+	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
+		ensure_tunnel
 
 		require 'net/http'
 
@@ -93,10 +98,46 @@ class Rush::Connection::Remote
 
 		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
+			process_result(res.code, res.body)
+		end
+	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

data/lib/rush/server.rb

@@ -21,23 +21,33 @@ class RushHandler < Mongrel::HttpHandler
 
 			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
+
+			msg = sprintf "%-20s", params[:action]
+			msg += without_action.inspect
+			msg += " + #{payload.size} bytes of payload" if payload.size > 0
+			log msg
 
 			params[:payload] = payload
-			result = box.connection.receive(params)
 
-			response.start(200) do |head, out|
-				out.write result
+			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 (.+)$/)
-			puts "Request with no authorization data"
+			log "Request with no authorization data"
 			return false
 		end
 
@@ -45,14 +55,14 @@ class RushHandler < Mongrel::HttpHandler
 		user, password = decoded.split(':', 2)
 
 		if user.nil? or user.length == 0 or password.nil? or password.length == 0
-			puts "Malformed user or password"
+			log "Malformed user or password"
 			return false
 		end
 
 		if password == config.passwords[user]
 			return true
 		else
-			puts "Access denied to #{user}"
+			log "Access denied to #{user}"
 			return false
 		end
 	end
@@ -64,6 +74,12 @@ class RushHandler < Mongrel::HttpHandler
 	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.
@@ -72,10 +88,30 @@ class RushServer
 		host = "127.0.0.1"
 		port = Rush::Config::DefaultPort
 
-		puts "rushd listening on #{host}:#{port}"
+		rushd = RushHandler.new
+		rushd.log "rushd listening on #{host}:#{port}"
 
 		h = Mongrel::HttpServer.new(host, port)
-		h.register("/", RushHandler.new)
+		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

@@ -7,11 +7,8 @@ module Rush
 		# 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
+			home = Rush::Dir.new(ENV['HOME']) if ENV['HOME']
+			pwd = Rush::Dir.new(ENV['PWD']) if ENV['PWD']
 
 			@config = Rush::Config.new
 
@@ -23,9 +20,11 @@ module Rush
 			Readline.completion_append_character = nil
 			Readline.completion_proc = completion_proc
 
-			eval @config.load_env, @pure_binding
+			@box = Rush::Box.new
+			@pure_binding = @box.instance_eval "binding"
+			$last_res = nil
 
-			eval "def processes; Rush::Box.new('localhost').processes; end", @pure_binding
+			eval @config.load_env, @pure_binding
 
 			commands = @config.load_commands
 			Rush::Dir.class_eval commands
@@ -37,7 +36,7 @@ module Rush
 			loop do
 				cmd = Readline.readline('rush> ')
 
-				finish if cmd.nil?
+				finish if cmd.nil? or cmd == 'exit'
 				next if cmd == ""
 				Readline::HISTORY.push(cmd)
 
@@ -46,8 +45,10 @@ module Rush
 					$last_res = res
 					eval("_ = $last_res", @pure_binding)
 					print_result res
-				rescue Exception => e
-					puts "Exception #{e.class}: #{e}"
+				rescue Rush::Exception => e
+					puts "Exception #{e.class} -> #{e}"
+				rescue ::Exception => e
+					puts "Exception #{e.class} -> #{e}"
 					e.backtrace.each do |t|
 						puts "   #{::File.expand_path(t)}"
 					end
@@ -90,7 +91,10 @@ module Rush
 		end
 
 		def path_parts(input)   # :nodoc:
-			input.match(/^(.+)\[(['"])([^\]]+)$/).to_a.slice(1, 3) rescue [ nil, nil, nil ]
+			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.
@@ -103,8 +107,13 @@ module Rush
 		# 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_]+$/)
+				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
@@ -112,7 +121,7 @@ module Rush
 						return dir.entries.select do |e|
 							e.name.match(/^#{partial_path}/)
 						end.map do |e|
-							possible_var + '[' + quote + e.name + (e.dir? ? "/" : "")
+							(pre || '') + original_var + '[' + quote + fixed_path + e.name + (e.dir? ? "/" : "")
 						end
 					end
 				end

data/lib/rush/ssh_tunnel.rb

@@ -13,21 +13,21 @@ class Rush::SshTunnel
 		@port
 	end
 
-	def ensure_tunnel
+	def ensure_tunnel(options={})
 		return if @port and tunnel_alive?
 
 		@port = config.tunnels[@real_host]
 
 		if !@port or !tunnel_alive?
-			setup_everything
+			setup_everything(options)
 		end
 	end
 
-	def setup_everything
+	def setup_everything(options={})
 		display "Connecting to #{@real_host}..."
 		push_credentials
 		launch_rushd
-		establish_tunnel
+		establish_tunnel(options)
 	end
 
 	def push_credentials
@@ -40,7 +40,7 @@ class Rush::SshTunnel
 		# 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"
+		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
@@ -48,11 +48,11 @@ class Rush::SshTunnel
 		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
+	def establish_tunnel(options={})
 		display "Establishing ssh tunnel"
 		@port = next_available_port
 
-		make_ssh_tunnel
+		make_ssh_tunnel(options)
 
 		tunnels = config.tunnels
 		tunnels[@real_host] = @port
@@ -66,7 +66,6 @@ class Rush::SshTunnel
 			:local_port => @port,
 			:remote_port => Rush::Config::DefaultPort,
 			:ssh_host => @real_host,
-			:stall_command => "sleep 9000"
 		}
 	end
 
@@ -85,8 +84,8 @@ class Rush::SshTunnel
 		raise SshFailed unless system("ssh #{@real_host} '#{command}'")
 	end
 
-	def make_ssh_tunnel
-		raise SshFailed unless system(ssh_tunnel_command)
+	def make_ssh_tunnel(options={})
+		raise SshFailed unless system(ssh_tunnel_command(options))
 	end
 
 	def ssh_tunnel_command_without_stall
@@ -95,8 +94,18 @@ class Rush::SshTunnel
 		"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]}\""
+	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

data/spec/box_spec.rb

@@ -15,4 +15,29 @@ describe Rush::Box do
 	it "looks up entries with [] syntax" do
 		@box['/'].should == Rush::Dir.new('/', @box)
 	end
+
+	it "looks up processes" do
+		@box.connection.should_receive(:processes).and_return([ { :pid => 123 } ])
+		@box.processes.should == [ Rush::Process.new({ :pid => 123 }, @box) ]
+	end
+
+	it "executes bash commands" do
+		@box.connection.should_receive(:bash).with('cmd').and_return('output')
+		@box.bash('cmd').should == 'output'
+	end
+
+	it "checks the connection to determine if it is alive" do
+		@box.connection.should_receive(:alive?).and_return(true)
+		@box.should be_alive
+	end
+
+	it "establish_connection to set up the connection manually" do
+		@box.connection.should_receive(:ensure_tunnel)
+		@box.establish_connection
+	end
+
+	it "establish_connection can take a hash of options" do
+		@box.connection.should_receive(:ensure_tunnel).with(:timeout => :infinite)
+		@box.establish_connection(:timeout => :infinite)
+	end
 end

data/spec/dir_spec.rb

@@ -145,4 +145,9 @@ describe Rush::Dir do
 		@dir.create_dir('a').create_file('b').write('c')
 		@dir.destroy
 	end
+
+	it "can run a bash command within itself" do
+		system "echo test > #{@dir.full_path}/file"
+		@dir.bash("cat file").should == "test\n"
+	end
 end

data/spec/entry_spec.rb

@@ -60,11 +60,11 @@ describe Rush::Entry do
 		new_file = "test3"
 		system "touch #{@sandbox_dir}/#{new_file}"
 
-		lambda { @entry.rename(new_file) }.should raise_error(Rush::Connection::Local::NameAlreadyExists)
+		lambda { @entry.rename(new_file) }.should raise_error(Rush::NameAlreadyExists, /#{new_file}/)
 	end
 
 	it "can't rename itself to something with a slash in it" do
-		lambda { @entry.rename('has/slash') }.should raise_error(Rush::Connection::Local::NameCannotContainSlash)
+		lambda { @entry.rename('has/slash') }.should raise_error(Rush::NameCannotContainSlash, /slash/)
 	end
 
 	it "can duplicate itself within the directory" do

data/spec/file_spec.rb

@@ -72,4 +72,8 @@ describe Rush::File do
 	it "can fetch contents or blank if doesn't exist" do
 		Rush::File.new('/does/not/exist').contents_or_blank.should == ""
 	end
+
+	it "can fetch lines, or empty if doesn't exist" do
+		Rush::File.new('/does/not/exist').lines_or_empty.should == []
+	end
 end

data/spec/find_by_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::FindBy do
+	before do
+		class Foo
+			attr_accessor :bar
+
+			def initialize(bar)
+				@bar = bar
+			end
+		end
+
+		@one = Foo.new('one')
+		@two = Foo.new('two')
+		@three = Foo.new('three')
+
+		@list = [ @one, @two, @three ]
+	end
+
+	it "compare_or_match exact match success" do
+		@list.compare_or_match('1', '1').should == true
+	end
+
+	it "compare_or_match exact match failure" do
+		@list.compare_or_match('1', '2').should == false
+	end
+
+	it "compare_or_match regexp match success" do
+		@list.compare_or_match('123', /2/).should == true
+	end
+
+	it "compare_or_match regexp match failure" do
+		@list.compare_or_match('123', /x/).should == false
+	end
+
+	it "find_by_ extact match" do
+		@list.find_by_bar('two').should == @two
+	end
+
+	it "find_by_ regexp match" do
+		@list.find_by_bar(/.hree/).should == @three
+	end
+
+	it "find_all_by_ exact match" do
+		@list.find_all_by_bar('one').should == [ @one ]
+	end
+
+	it "find_all_by_ regexp match" do
+		@list.find_all_by_bar(/^...$/).should == [ @one, @two ]
+	end
+
+	it "find_by_ with field not recognized by objects raises no errors" do
+		@list.find_by_nothing('x')
+	end
+end